@somacheck/vibecheck 0.6.0 → 0.6.2

package/README.md

@@ -1,7 +1,7 @@
 # @somacheck/vibecheck
 
-An MCP server that lets an AI agent ask its human a question and get back an
-answer given with a physical wrist gesture, through the SomaCheck iOS app.
+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.
 
 Your agent has your context. It does not have your gut. This is the bridge.
 
@@ -9,7 +9,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.0 link <CODE> --client <CLIENT>`
+**What the `link` command does.** `npx -y @somacheck/vibecheck@0.6.2 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
@@ -78,9 +78,9 @@ before the pairing code is redeemed.
 To configure or repair a client later:
 
 ```text
-npx -y @somacheck/vibecheck@0.6.0 setup codex
-npx -y @somacheck/vibecheck@0.6.0 setup claude
-npx -y @somacheck/vibecheck@0.6.0 doctor
+npx -y @somacheck/vibecheck@0.6.2 setup codex
+npx -y @somacheck/vibecheck@0.6.2 setup claude
+npx -y @somacheck/vibecheck@0.6.2 doctor
 ```
 
 Manual registration remains available:
@@ -90,13 +90,13 @@ Manual registration remains available:
      "mcpServers": {
        "vibecheck": {
          "command": "npx",
-        "args": ["-y", "@somacheck/vibecheck@0.6.0", "serve", "--client", "codex"]
+        "args": ["-y", "@somacheck/vibecheck@0.6.2", "serve", "--client", "codex"]
        }
      }
    }
    ```
 
-   For Claude Code: `claude mcp add --scope user vibecheck -- npx -y @somacheck/vibecheck@0.6.0 serve --client claude`
+   For Claude Code: `claude mcp add --scope user vibecheck -- npx -y @somacheck/vibecheck@0.6.2 serve --client claude`
 
 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
@@ -107,6 +107,39 @@ If `doctor` reports another MCP server named `somacheck`, that is the legacy
 hosted connector and is separate from this local package. The setup command
 will explain it and leave it alone. The canonical local MCP key is `vibecheck`.
 
+## Teach your agent when to offer a check-in
+
+[`SKILL.md`](SKILL.md) teaches compatible agents two behaviors: act immediately
+when the person explicitly requests a vibecheck, and offer one optional
+vibecheck when work drifts, a consequential decision is imminent, or recent
+messages show multiple stress signals. It uses `request_vibecheck`, not the
+reflection-feed batch tool. It includes transcript-grounded heuristics,
+statement templates, a two-hour decline cooldown, privacy rules, and the
+requirement to treat every result as context rather than authorization.
+
+For Claude Code, add this repository as a marketplace and install the skill in
+one terminal command:
+
+```text
+claude plugin marketplace add sensie-app/Somacheck && claude plugin install vibecheck@somacheck
+```
+
+Inside Claude Code, the equivalent commands are:
+
+```text
+/plugin marketplace add sensie-app/Somacheck
+/plugin install vibecheck@somacheck
+```
+
+For agents supported by the Skills CLI:
+
+```text
+npx skills add sensie-app/Somacheck --skill vibecheck
+```
+
+The skill expects the `@somacheck/vibecheck` MCP server to already be linked as
+`vibecheck`. Installing the skill does not copy or replace the bearer token.
+
 ## Tools
 
 | Tool | What it does |
@@ -116,27 +149,69 @@ will explain it and leave it alone. The canonical local MCP key is `vibecheck`.
 | `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. |
 | `get_vibecheck_result` | Read that exact proposition once by `request_id`; returns queued, pending, or its terminal result. |
-| `request_vibecheck` | After the person accepts the exact statement, send one immediate phone vibecheck with a retry-safe UUID and return an opaque `live:<uuid>` handle. |
+| `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. |
 
 ## How to use it well
 
 Ask when you genuinely need a read you cannot infer — not to check in. A good
 prompt is **a statement for the person to test**, not a question about facts:
-"you are more worried about the launch than the roadmap suggests." Offer it as
-something to test, never as a claim about them. If it is wrong, their body says
-`unaligned`, and that is a useful answer rather than a failure.
-
-For a Live Ask, first show the exact statement and invite the person plainly:
+“I feel more concerned about the launch than the roadmap suggests.” Offer it as
+something to test, never as a claim about them. An `unaligned` result is another
+signal to consider; the person decides whether it matches what they notice.
+
+Setup and linking are not permission for future asks. If the person's current
+message explicitly asks for a SomaCheck vibecheck, that is consent for one ask.
+Use their exact statement when supplied. If they delegated the choice, select
+the most useful first-person statement from the current conversation, goal,
+decision, or tension and send it immediately—do not ask them for wording or a
+second confirmation. Remembered context may identify a general tension, but an
+agent-selected statement must not name a project, build, branch, wave, ticket,
+task status, or supposedly open/closed work. Abstract it into a present-tense
+first-person experience or choice, such as “I want to keep consolidating what is
+already in motion rather than start something new.” Preserve exact wording the
+person supplied. If meaningful context is unavailable, use the neutral fallback
+“I feel clear about what deserves my attention right now.”
+
+If their message did not explicitly request a vibecheck, first show the exact
+statement and invite the person plainly:
 
 > Want a quick vibecheck before I continue? I'll send this statement to your
 > phone; you answer with your wrist gesture, and I'll use the result as a
 > signal—not a verdict.
 
-Call `request_vibecheck` only after they accept, with `human_confirmed: true`
-and a new UUID in `idempotency_key`. Reuse that UUID only when retrying the
-same statement. The returned `live:<uuid>` handle can be passed to
-`get_vibecheck_result` later. Each read is non-blocking; do not continuously
-poll, and do not re-ask the same decision to obtain a preferred result.
+Call `request_vibecheck` with `consent_basis: "user_requested_vibecheck"` for a
+direct request or `consent_basis: "user_approved_statement"` after approval of
+agent-proposed wording, plus a new UUID in `idempotency_key`. Reuse that UUID
+only when retrying the same statement. The tool keeps the one created request
+open for a bounded wait and returns `completed` when the exact answer arrives.
+On timeout or a result-read failure it returns the same pending `live:<uuid>`
+handle; pass that handle to `get_vibecheck_result` once later. Caller
+cancellation stops result reads and preserves the backend request and
+idempotency key, but the cancelled MCP transport may suppress that pending
+response. Do not continuously poll or re-ask the same decision to obtain a
+preferred result.
+
+Standard MCP cannot start a new agent turn after that bounded tool call has
+ended. The local Claude Code runtime therefore also advertises Anthropic's
+opt-in `claude/channel` capability. When Claude Code is launched with the
+SomaCheck server enabled as a channel, one local background watcher follows
+only the exact pending request. It emits one hardcoded, secret-free channel
+event when that request becomes answered, expired, or cancelled. The event
+contains the constrained lifecycle result and opaque handle, never the private
+statement or link token, and it cannot create another phone request.
+
+Claude Code channels are currently a research preview and only receive events
+while the opted-in session remains open. For local QA of this candidate, launch
+Claude Code with `--dangerously-load-development-channels server:vibecheck`.
+Production distribution requires the SomaCheck channel plugin to be accepted by
+Anthropic's channel allowlist (or explicitly allowed by an organization).
+Claude Desktop, hosted connectors, Codex, and other standard MCP hosts retain
+the bounded tool response and stable-handle fallback; this Claude-specific
+channel must never be presented as provider-neutral behavior.
+
+The 45-second whole-call deadline also covers the one create request. If that
+network request is aborted after an ambiguous commit, retry the exact same
+statement with the same `idempotency_key`; never create a replacement ask.
 
 After a completed result, explain what the signal changes in your next action.
 Never treat it as authorization or say that the person's body made the

package/dist/api.js

@@ -334,7 +334,7 @@ export class SupabaseAgentApi {
         const row = await this.#rpc("agent_link_redeem", { code });
         return requiredString(row, "token");
     }
-    async requestVibecheck(token, identity, statement, idempotencyKey) {
+    async requestVibecheck(token, identity, statement, idempotencyKey, signal) {
         if (identity.kind !== "local")
             throw new SomaCheckLiveAskClientError();
         const clientKey = identity.client_key;
@@ -343,9 +343,9 @@ export class SupabaseAgentApi {
             statement,
             idempotency_key: idempotencyKey,
             client_key: clientKey,
-        }));
+        }, signal));
         const lifecycle = created.status === "answered"
-            ? await this.liveVibecheckResult(token, identity, created.request_id)
+            ? await this.liveVibecheckResult(token, identity, created.request_id, signal)
             : { status: created.status, verdict: null, confidence: null, latency_s: null };
         return {
             request_id: `live:${created.request_id}`,
@@ -364,14 +364,14 @@ export class SupabaseAgentApi {
     async pollRequest(token, requestId) {
         return decodePollResponse(await this.#rpc("agent_proposition_result", { token, proposition_id: requestId }));
     }
-    async liveVibecheckResult(token, identity, requestId) {
+    async liveVibecheckResult(token, identity, requestId, signal) {
         if (identity.kind !== "local")
             throw new SomaCheckLiveAskClientError();
         return decodeLiveVibecheckResult(await this.#rpcJson("agent_vibecheck_result", {
             token,
             live_ask_id: requestId,
             client_key: identity.client_key,
-        }), requestId);
+        }, signal), requestId);
     }
     async statusRequest(token) {
         return decodeVibecheckStatus(await this.#rpc("agent_proposition_cache_status", { token }));
@@ -418,7 +418,7 @@ export class SupabaseAgentApi {
     async #rpc(name, body) {
         return firstRow(await this.#rpcJson(name, body));
     }
-    async #rpcJson(name, body) {
+    async #rpcJson(name, body, signal) {
         const response = await this.#fetch(`${this.#endpoint}/rest/v1/rpc/${name}`, {
             method: "POST",
             headers: {
@@ -429,6 +429,7 @@ export class SupabaseAgentApi {
                 "accept-profile": "somacheck_engine",
             },
             body: JSON.stringify(body),
+            ...(signal === undefined ? {} : { signal }),
         });
         if (!response.ok) {
             const responseBody = await response.text().catch(() => "");

package/dist/client-setup.js

@@ -91,6 +91,8 @@ function registrationMatches(client, stdout) {
             return false;
         }
     }
+    if (/^\s*(?:Enabled|Status):\s*(?:false|disabled|off)\s*$/im.test(stdout))
+        return false;
     const command = /^\s*Command:\s*(\S+)\s*$/im.exec(stdout)?.[1];
     const rawArgs = /^\s*Args:\s*(.*?)\s*$/im.exec(stdout)?.[1] ?? "";
     const parsedArgs = rawArgs.split(/\s+/).filter(Boolean);
@@ -117,6 +119,8 @@ function isManagedSomaCheckRegistration(client, stdout) {
         }
     }
     else {
+        if (/^\s*(?:Enabled|Status):\s*(?:false|disabled|off)\s*$/im.test(stdout))
+            return false;
         command = /^\s*Command:\s*(\S+)\s*$/im.exec(stdout)?.[1];
         args = (/^\s*Args:\s*(.*?)\s*$/im.exec(stdout)?.[1] ?? "").split(/\s+/).filter(Boolean);
     }
@@ -131,10 +135,13 @@ function isManagedSomaCheckRegistration(client, stdout) {
     if (legacyWithoutClient)
         return true;
     // 0.5 introduced the exact local runtime identity required by Live Ask.
-    // It is safe to replace only the canonical command generated by that
-    // release. Custom wrappers, extra arguments, disabled entries, and a
-    // registration naming the other client remain user-owned.
-    const previousExactClient = /^@somacheck\/vibecheck@0\.5\.\d+$/.test(packageArg)
+    // It is safe to replace only the canonical command generated by 0.5 or an
+    // 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")
         && args.length === 5
         && args[0] === "-y"
         && args[1] === packageArg

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.0";
+export const PACKAGE_VERSION = "0.6.2";
 export const PACKAGE_SPEC = `${PACKAGE_NAME}@${PACKAGE_VERSION}`;
 export const MCP_SERVER_NAME = "vibecheck";
 export const LEGACY_HOSTED_MCP_SERVER_NAME = "somacheck";

package/dist/server.js

@@ -3,6 +3,29 @@ import { z } from "zod";
 import { StatementPendingError, } from "./vibecheck.js";
 import { SomaCheckCompatibilityError, SomaCheckHttpError, SomaCheckLiveAskClientError, SomaCheckLiveAskConflictError, SomaCheckLiveAskPendingError, } from "./api.js";
 import { PACKAGE_NAME, PACKAGE_SPEC, PACKAGE_VERSION } from "./constants.js";
+const LIVE_ASK_WAIT_BUDGET_MS = 45_000;
+const LIVE_ASK_POLL_DELAYS_MS = [
+    1_000, 1_000, 2_000, 2_000, 3_000, 3_000,
+    4_000, 4_000, 5_000, 5_000, 5_000, 5_000,
+];
+const CLAUDE_CHANNEL_POLL_INTERVAL_MS = 2_000;
+const CLAUDE_CHANNEL_MAX_WATCH_MS = 15 * 60 * 1_000;
+const CLAUDE_CHANNEL_RESULT_TIMEOUT_MS = 10_000;
+function abortAwareSleep(milliseconds, signal) {
+    if (signal.aborted || milliseconds <= 0)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        let timer;
+        const finish = () => {
+            if (timer !== undefined)
+                clearTimeout(timer);
+            signal.removeEventListener("abort", finish);
+            resolve();
+        };
+        timer = setTimeout(finish, milliseconds);
+        signal.addEventListener("abort", finish, { once: true });
+    });
+}
 const cadenceSchema = z.object({
     reason: z.string(),
     create_due_at: z.string().nullable(),
@@ -89,13 +112,20 @@ const contextShareSchema = {
 };
 const SERVER_INSTRUCTIONS = [
     "SomaCheck lets you offer the person a statement to test through a quick phone check-in.",
+    "MANDATORY COMMAND RULE: when the current user message says 'Give me a SomaCheck vibecheck', 'Request a SomaCheck vibecheck', or otherwise explicitly asks for one, you must call request_vibecheck in that same turn after any read-only context/status calls. Do not present a draft, ask 'Want me to send this?', or wait for another yes. The request itself is one-ask consent for you to select and send the statement.",
     "Call get_vibecheck_context and get_vibecheck_status at the start of a session or background run, and call status again after a completed check-in.",
     "Treat gesture outcomes as contextual signals, never fixed facts or blanket authorization.",
     "Use request_vibecheck when a current choice would benefit from the person's own felt response; never use it to evaluate someone else.",
-    "First show the exact statement and ask: Want a quick vibecheck before I continue? I'll send this statement to your phone; you answer with your wrist gesture, and I'll use the result as a signal—not a verdict. Call only after the person accepts.",
+    "A setup or link is not blanket consent for future vibechecks.",
+    "If the person's current message explicitly requests a SomaCheck vibecheck, that message is consent for one ask. If they supplied exact wording, use it. Otherwise, choose one useful statement from the current conversation, goal, decision, or tension and send it immediately; do not ask them to supply wording or confirm twice.",
+    "DELEGATED SELECTION RULE: when you choose the wording, remembered context may identify a general tension but the statement itself must not name a project, build, branch, wave, ticket, task status, or supposedly open/closed work. Abstract it into a present-tense first-person experience or choice, such as 'I want to keep consolidating what is already in motion rather than start something new.' This restriction does not alter exact wording supplied by the person.",
+    "When choosing the statement, prefer the most consequential unresolved first-person decision or tension you already understand. Treat recalled project status, task lists, and old summaries as potentially stale. Never use them as a factual premise for agent-selected wording, even if they were recalled in the current turn. If context is thin, use the neutral fallback 'I feel clear about what deserves my attention right now.' Never diagnose, judge another person, or claim certainty about the user.",
+    "Otherwise, first show the exact statement and ask: Want a quick vibecheck before I continue? I'll send this statement to your phone; you answer with your wrist gesture, and I'll use the result as a signal—not a verdict. Call only after the person accepts.",
     "Use at most one vibecheck per decision. Never re-ask to obtain a preferred answer.",
     "An immediate vibecheck is separate from the asynchronous reflection feed. Do not use it to replenish cached propositions.",
     "Use a fresh idempotency_key for each new vibecheck, and reuse that exact key only when retrying the same statement.",
+    "request_vibecheck waits boundedly for the exact answer. If it returns completed, continue in the same turn and explain what changes. If it returns pending, retain that exact handle and read it once later; never create a replacement ask.",
+    "If request_vibecheck returns pending, never promise that you will check back on your own. Only continue automatically after an actual SomaCheck channel event arrives for that exact request.",
     "After a completed result, say what the signal changes in your next action. Never say 'your body decided'; a typed human response always overrides the signal.",
     "When you have meaningful user-authorized context, call share_somacheck_context with concise derived observations before creating propositions.",
     "Never share raw conversation text, photos, credentials, private identifiers, or diagnostic claims.",
@@ -106,7 +136,34 @@ const SERVER_INSTRUCTIONS = [
     "Do not poll continuously. Queued means the proposition is cached until the person advances their feed.",
 ].join(" ");
 export function createVibecheckServer(dependencies) {
-    const server = new McpServer({ name: PACKAGE_NAME, version: PACKAGE_VERSION }, { instructions: SERVER_INSTRUCTIONS });
+    const supportsClaudeChannel = dependencies.identity?.kind === "local"
+        && dependencies.identity.client_key === "claude";
+    const server = new McpServer({ name: PACKAGE_NAME, version: PACKAGE_VERSION }, {
+        instructions: SERVER_INSTRUCTIONS,
+        ...(supportsClaudeChannel
+            ? { capabilities: { experimental: { "claude/channel": {} } } }
+            : {}),
+    });
+    const claudeChannelWatches = new Set();
+    const claudeChannelNotified = new Set();
+    const startClaudeChannelWatch = (created, token, identity) => {
+        if (!supportsClaudeChannel || dependencies.claudeChannelWatch === false)
+            return;
+        if (created.state !== "pending"
+            || created.delivery_state === "failed"
+            || created.delivery_state === "skipped")
+            return;
+        const requestId = parseLiveVibecheckHandle(created.request_id);
+        if (requestId === null
+            || claudeChannelWatches.has(requestId)
+            || claudeChannelNotified.has(requestId))
+            return;
+        claudeChannelWatches.add(requestId);
+        void watchForClaudeChannelResult(created, token, identity, dependencies, async (notification) => {
+            claudeChannelNotified.add(requestId);
+            await server.server.notification(notification);
+        }).finally(() => claudeChannelWatches.delete(requestId));
+    };
     server.registerTool("get_vibecheck_context", {
         title: "Vibecheck Context",
         description: "Read recent completed check-ins for this linked agent, newest first. Use the outcomes as contextual signals and replenish the feed when status requests it.",
@@ -257,14 +314,14 @@ export function createVibecheckServer(dependencies) {
     });
     server.registerTool("request_vibecheck", {
         title: "Request a Vibecheck",
-        description: "Send one plain-language statement to the person's phone for a vibecheck answered with a wrist gesture. First show the exact statement and call only after the person accepts. Use this only when their own felt response would help with the current choice, not for routine feed content or to judge another person. Returns a stable request_id immediately; call get_vibecheck_result later once, without continuous polling.",
+        description: "Send one plain-language statement to the person's phone for a vibecheck answered with a wrist gesture. A current user message that explicitly requests a SomaCheck vibecheck is confirmation for one ask. Use their exact wording when supplied; otherwise choose and send one present-tense first-person experience or choice immediately without asking for wording or reconfirmation. When you choose the wording, remembered context may identify only the general tension: never put a named project, build, branch, wave, ticket, task status, or supposedly open/closed work into the statement, even when recalled in the current turn. Abstract it, for example: 'I want to keep consolidating what is already in motion rather than start something new.' If context is thin, use the neutral fallback 'I feel clear about what deserves my attention right now.' Otherwise, first show the exact statement and call only after the person accepts. Setup or linking is not blanket consent. Use this only when their own felt response would help with the current choice, not for routine feed content, diagnosis, or judging another person. The call waits boundedly for the exact result and returns completed when available. A timeout returns the same stable pending request_id for one later read. Caller cancellation stops result reads without creating another request; the cancelled transport may suppress the pending response.",
         inputSchema: {
             statement: z.string().trim().min(1).max(1000)
-                .describe("One plain-language statement for the person to test; offer a signal, not a fact, diagnosis, or instruction."),
+                .describe("One plain-language statement for the person to test; offer a signal, not a fact, diagnosis, or instruction. If the agent selected the wording, it must be a present-tense first-person experience or choice and must not name remembered projects, builds, branches, waves, tickets, task status, or supposedly open/closed work. Preserve exact wording supplied by the person."),
             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."),
-            human_confirmed: z.literal(true)
-                .describe("Confirms the agent showed the exact statement and the person accepted this one vibecheck."),
+            consent_basis: z.enum(["user_requested_vibecheck", "user_approved_statement"])
+                .describe("Required one-ask consent basis. Use user_requested_vibecheck when the current message asks for a SomaCheck vibecheck, including when the agent chooses the statement; call immediately without another confirmation. Use user_approved_statement only after the agent proposed exact wording and the person accepted it."),
         },
         outputSchema: liveAskSchema,
         annotations: {
@@ -273,30 +330,194 @@ export function createVibecheckServer(dependencies) {
             idempotentHint: true,
             openWorldHint: false,
         },
-    }, async ({ statement, idempotency_key }) => {
+    }, async ({ statement, idempotency_key }, extra) => {
+        const now = dependencies.liveAskWait?.now ?? (() => performance.now());
+        const budgetMs = dependencies.liveAskWait?.budgetMs ?? LIVE_ASK_WAIT_BUDGET_MS;
+        const deadline = now() + budgetMs;
+        const callAbort = new AbortController();
+        const forwardCallerAbort = () => callAbort.abort(extra.signal.reason);
+        if (extra.signal.aborted) {
+            forwardCallerAbort();
+        }
+        else {
+            extra.signal.addEventListener("abort", forwardCallerAbort, { once: true });
+        }
+        const callDeadline = setTimeout(() => callAbort.abort(new Error("Live Ask tool deadline reached.")), budgetMs);
         try {
             const identity = dependencies.identity ?? { kind: "legacy" };
             if (identity.kind === "legacy") {
                 return liveAskFailure(new SomaCheckLiveAskClientError());
             }
             const token = await dependencies.loadToken();
-            const result = await dependencies.api.requestVibecheck(token, identity, statement.trim(), idempotency_key);
+            const created = await dependencies.api.requestVibecheck(token, identity, statement.trim(), idempotency_key, callAbort.signal);
+            const result = await waitForLiveVibecheck(created, token, identity, dependencies, callAbort.signal, deadline, (attempt) => {
+                const progressToken = extra._meta?.progressToken;
+                if (progressToken === undefined)
+                    return;
+                void extra.sendNotification({
+                    method: "notifications/progress",
+                    params: {
+                        progressToken,
+                        progress: attempt,
+                        total: LIVE_ASK_POLL_DELAYS_MS.length,
+                        message: "Waiting for the person's vibecheck signal.",
+                    },
+                }).catch(() => {
+                    // Progress is optional. A host that does not accept it must not
+                    // prevent the exact result from completing this tool call.
+                });
+            });
+            startClaudeChannelWatch(result, token, identity);
             const structuredContent = { ...result, error_code: null };
             const text = result.state === "completed"
                 ? `Vibecheck completed: ${Math.round((result.confidence ?? 0) * 100)}% ${result.verdict}. Treat this as a signal, say what it changes in your next action, and defer to any typed response from the person.`
                 : result.state === "pending"
                     ? result.delivery_state === "failed" || result.delivery_state === "skipped"
                         ? `Vibecheck ${result.request_id} was stored, but phone delivery is ${result.delivery_state}. It expires at ${result.expires_at}. Do not repost it or change the idempotency_key; check the phone setup before a later decision.`
-                        : `Vibecheck requested. Keep request_id ${result.request_id} and check it later with get_vibecheck_result. It expires at ${result.expires_at}; do not poll continuously or re-ask for this decision.`
+                        : `Vibecheck ${result.request_id} is still pending after a bounded wait. Keep this exact handle and check it once later with get_vibecheck_result. It expires at ${result.expires_at}; do not poll continuously, re-ask for this decision, or promise an automatic follow-up unless an actual SomaCheck channel event arrives.`
                     : `This vibecheck is ${result.state}. Do not create another ask for the same decision.`;
             return { content: [{ type: "text", text }], structuredContent };
         }
         catch (error) {
             return liveAskFailure(error);
         }
+        finally {
+            clearTimeout(callDeadline);
+            extra.signal.removeEventListener("abort", forwardCallerAbort);
+        }
     });
     return server;
 }
+async function watchForClaudeChannelResult(created, token, identity, dependencies, notify) {
+    const requestId = parseLiveVibecheckHandle(created.request_id);
+    if (requestId === null || identity.kind !== "local" || identity.client_key !== "claude")
+        return;
+    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 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);
+    let consecutiveReadFailures = 0;
+    while (now() < deadline) {
+        await sleep(Math.min(interval, Math.max(0, deadline - now())));
+        if (now() >= deadline)
+            return;
+        const readAbort = new AbortController();
+        const readTimeout = setTimeout(() => readAbort.abort(new Error("Claude channel result read timed out.")), CLAUDE_CHANNEL_RESULT_TIMEOUT_MS);
+        readTimeout.unref?.();
+        let lifecycle;
+        try {
+            lifecycle = await dependencies.api.liveVibecheckResult(token, identity, requestId, readAbort.signal);
+            consecutiveReadFailures = 0;
+        }
+        catch {
+            consecutiveReadFailures += 1;
+            if (consecutiveReadFailures >= 3)
+                return;
+            continue;
+        }
+        finally {
+            clearTimeout(readTimeout);
+        }
+        if (lifecycle.status === "pending")
+            continue;
+        const handle = `live:${requestId}`;
+        const content = lifecycle.status === "answered"
+            ? `A SomaCheck vibecheck requested by this Claude connection has completed. The exact result is ${lifecycle.verdict} with confidence ${formatChannelConfidence(lifecycle.confidence)}. Treat it as a signal, not a verdict. Continue the current conversation now: briefly acknowledge the signal and state what it changes in your next action. The exact opaque request handle is ${handle}. Do not request another vibecheck for this decision.`
+            : `A SomaCheck vibecheck requested by this Claude connection is now ${lifecycle.status}. The exact opaque request handle is ${handle}. Do not create a replacement request for the same decision.`;
+        try {
+            await notify({
+                method: "notifications/claude/channel",
+                params: {
+                    content,
+                    meta: {
+                        event: "vibecheck_result",
+                        request_id: handle,
+                        status: lifecycle.status,
+                    },
+                },
+            });
+        }
+        catch {
+            // Channel opt-in is client-controlled and experimental. A host that did
+            // not enable it must not crash the MCP server or cause duplicate events.
+        }
+        return;
+    }
+}
+function unrefSleep(milliseconds) {
+    if (milliseconds <= 0)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, milliseconds);
+        timer.unref?.();
+    });
+}
+function formatChannelConfidence(confidence) {
+    return confidence === null ? "unavailable" : confidence.toFixed(2);
+}
+async function waitForLiveVibecheck(created, token, identity, dependencies, signal, deadline, progress) {
+    if (created.state !== "pending"
+        || created.delivery_state === "failed"
+        || created.delivery_state === "skipped"
+        || signal.aborted) {
+        return created;
+    }
+    const requestId = parseLiveVibecheckHandle(created.request_id);
+    if (requestId === null)
+        return created;
+    const now = dependencies.liveAskWait?.now ?? (() => performance.now());
+    const sleep = dependencies.liveAskWait?.sleep ?? abortAwareSleep;
+    for (const [index, delay] of LIVE_ASK_POLL_DELAYS_MS.entries()) {
+        const remaining = deadline - now();
+        if (signal.aborted || remaining <= 0)
+            return created;
+        await sleep(Math.min(delay, remaining), signal);
+        if (signal.aborted || now() >= deadline)
+            return created;
+        progress(index + 1);
+        if (signal.aborted)
+            return created;
+        let lifecycle;
+        const resultAbort = new AbortController();
+        const forwardCallerAbort = () => resultAbort.abort(signal.reason);
+        signal.addEventListener("abort", forwardCallerAbort, { once: true });
+        const resultTimeout = setTimeout(() => resultAbort.abort(new Error("Live Ask result deadline reached.")), Math.max(0, deadline - now()));
+        try {
+            lifecycle = await dependencies.api.liveVibecheckResult(token, identity, requestId, resultAbort.signal);
+        }
+        catch {
+            // Creation already succeeded. Keep the exact handle so a transient,
+            // cancelled, revoked, or deadline-aborted read cannot prompt a duplicate.
+            return created;
+        }
+        finally {
+            clearTimeout(resultTimeout);
+            signal.removeEventListener("abort", forwardCallerAbort);
+        }
+        if (signal.aborted)
+            return created;
+        if (lifecycle.status === "answered") {
+            return {
+                ...created,
+                state: "completed",
+                verdict: lifecycle.verdict,
+                confidence: lifecycle.confidence,
+            };
+        }
+        if (lifecycle.status === "expired" || lifecycle.status === "cancelled") {
+            return {
+                ...created,
+                state: lifecycle.status,
+                verdict: null,
+                confidence: null,
+            };
+        }
+    }
+    return created;
+}
 function summarise(status) {
     const cadence = status.cadence;
     if (status.first_run_intro.should_offer_now) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@somacheck/vibecheck",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Send a consented vibecheck to SomaCheck and use the result as a signal.",
   "repository": {
     "type": "git",
@@ -19,7 +19,8 @@
   ],
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.json",
-    "test": "npm run build && node --import tsx --test test/*.test.ts && node --test test/*.test.mjs",
+    "test": "npm run build && node --import tsx --test test/*.test.ts && node --test test/*.test.mjs && npm run test:skill",
+    "test:skill": "python3 test/skill-triggers/verify.py",
     "test:release-artifacts": "bash ./verify-release-artifacts.sh",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "prepack": "npm run build"