@somacheck/vibecheck 0.6.4 → 0.6.6

package/README.md

@@ -9,11 +9,13 @@ 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.4 link <CODE> --client <CLIENT>`
+**What the `link` command does.** `npx -y @somacheck/vibecheck@0.6.6 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. Setup is not reported ready until 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.
@@ -28,7 +30,8 @@ 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. If that preflight
+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,
 `--client all`, and `--client none` are rejected before redemption.
 
@@ -78,9 +81,9 @@ before the pairing code is redeemed.
 To configure or repair a client later:
 
 ```text
-npx -y @somacheck/vibecheck@0.6.4 setup codex
-npx -y @somacheck/vibecheck@0.6.4 setup claude
-npx -y @somacheck/vibecheck@0.6.4 doctor
+npx -y @somacheck/vibecheck@0.6.6 setup codex
+npx -y @somacheck/vibecheck@0.6.6 setup claude
+npx -y @somacheck/vibecheck@0.6.6 doctor
 ```
 
 Manual registration remains available:
@@ -90,13 +93,13 @@ Manual registration remains available:
      "mcpServers": {
        "vibecheck": {
          "command": "npx",
-        "args": ["-y", "@somacheck/vibecheck@0.6.4", "serve", "--client", "codex"]
+        "args": ["-y", "@somacheck/vibecheck@0.6.6", "serve", "--client", "codex"]
        }
      }
    }
    ```
 
-   For Claude Code: `claude mcp add --scope user vibecheck -- npx -y @somacheck/vibecheck@0.6.4 serve --client claude`
+   For Claude Code: `claude mcp add --scope user vibecheck -- npx -y @somacheck/vibecheck@0.6.6 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,15 +110,15 @@ 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
+## Teach your agent when to use SomaCheck
 
-[`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.
+[`SKILL.md`](SKILL.md) teaches compatible agents one simple affordance:
+SomaCheck lets them ask their person for a vibecheck. The agent can offer one
+when it believes the read would help, or send one when the person asks. The
+skill keeps only the essential boundaries: ask the person, choose a useful
+first-person statement from available context, treat the returned gesture and
+optional feedback as context rather than authorization, and never include
+secrets or assess anyone else.
 
 For Claude Code, add this repository as a marketplace and install the skill in
 one terminal command:
@@ -153,31 +156,11 @@ The skill expects the `@somacheck/vibecheck` MCP server to already be linked as
 
 ## 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:
-“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 or check-in, 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 list candidates, ask them
-for wording, or seek 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.
+Ask when the person's felt response would be useful context. A good prompt is a
+first-person statement for the person to test, not a claim about them. When the
+person asks for a vibecheck, choose and send a useful statement from the context
+available to you. For proactive offers, get the person's acceptance before
+sending.
 
 Call `request_vibecheck` with `consent_basis: "user_requested_vibecheck"` for a
 direct request or `consent_basis: "user_approved_statement"` after approval of
@@ -188,37 +171,24 @@ 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
+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.
+
+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.
+
+The 10-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, reconcile it with the current goal, state one
-observable change, and continue with the next reversible in-scope action when
-it is already authorized. Do not stop at repeating the verdict, confidence, or
-generic signal language.
-Never treat it as authorization or say that the person's body made the
-decision. A typed response from the person always overrides the signal.
+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.

package/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: vibecheck
+description: Ask your person for a SomaCheck vibecheck when it would help.
+user-invocable: true
+allowed-tools: mcp__vibecheck__get_vibecheck_context mcp__vibecheck__get_vibecheck_status mcp__vibecheck__get_vibecheck_result mcp__vibecheck__request_vibecheck
+---
+
+# Vibecheck
+
+SomaCheck lets you ask your person for a vibecheck.
+
+Use `request_vibecheck` in either case:
+
+1. You proactively offer one because you believe it would be 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.
+
+For proactive offers, get the person's acceptance before sending.
+
+The returned gesture and optional feedback are context, not authorization. Use your judgment in how you interpret and respond.
+
+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/claude-marketplace/.claude-plugin/marketplace.json

@@ -0,0 +1,22 @@
+{
+  "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.6",
+      "author": {
+        "name": "Sensie",
+        "email": "agents@joinsensie.com"
+      },
+      "category": "productivity",
+      "tags": ["vibecheck", "somacheck", "decision-support", "mcp"]
+    }
+  ]
+}

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

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

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

@@ -0,0 +1,18 @@
+{
+  "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.6 claude-hook await-result",
+            "asyncRewake": true,
+            "timeout": 900
+          }
+        ]
+      }
+    ]
+  }
+}

package/dist/api.js

@@ -8,6 +8,7 @@ const LIVE_ASK_CLIENT_REQUIRED_MARKER = "SC_VC_VIBECHECK_CLIENT_REQUIRED";
 const LIVE_ASK_CLIENT_NOT_READY_MARKER = "SC_VC_VIBECHECK_CLIENT_NOT_READY";
 const STATUSES = new Set(["queued", "pending", "answered", "expired", "cancelled"]);
 const VERDICTS = new Set(["aligned", "unaligned"]);
+const USER_FEEDBACKS = new Set(["agreed", "disagreed", "not_provided"]);
 const HANDSHAKE_READINESS_STATUSES = new Set([
     "ready",
     "upgrade_required",
@@ -222,6 +223,7 @@ export function decodePollResponse(value) {
     const verdict = row.verdict;
     const confidence = row.confidence;
     const latency = row.latency_s;
+    const userFeedback = row.user_feedback ?? null;
     if (verdict !== null && (typeof verdict !== "string" || !VERDICTS.has(verdict))) {
         throw new Error("SomaCheck returned an invalid verdict.");
     }
@@ -231,6 +233,9 @@ export function decodePollResponse(value) {
     if (latency !== null && (typeof latency !== "number" || !Number.isFinite(latency) || latency < 0)) {
         throw new Error("SomaCheck returned an invalid latency.");
     }
+    if (userFeedback !== null && (typeof userFeedback !== "string" || !USER_FEEDBACKS.has(userFeedback))) {
+        throw new Error("SomaCheck returned invalid user feedback.");
+    }
     if (status === "answered") {
         if (verdict === null || confidence === null || confidence < 0 || confidence > 1 || latency === null) {
             throw new Error("SomaCheck returned an incomplete answered result.");
@@ -239,12 +244,21 @@ export function decodePollResponse(value) {
     else if (verdict !== null || confidence !== null || latency !== null) {
         throw new Error("SomaCheck returned an inconsistent pending result.");
     }
-    return {
+    if (status !== "answered" && userFeedback !== null) {
+        throw new Error("SomaCheck returned inconsistent feedback for an unanswered result.");
+    }
+    const decoded = {
         status: status,
         verdict: verdict,
         confidence: confidence,
         latency_s: latency,
     };
+    if (userFeedback === null)
+        return decoded;
+    return {
+        ...decoded,
+        user_feedback: userFeedback,
+    };
 }
 export function decodeLiveVibecheckResult(value, expectedRequestId) {
     const row = firstRow(value);
@@ -347,7 +361,7 @@ export class SupabaseAgentApi {
         const lifecycle = created.status === "answered"
             ? await this.liveVibecheckResult(token, identity, created.request_id, signal)
             : { status: created.status, verdict: null, confidence: null, latency_s: null };
-        return {
+        const liveRequest = {
             request_id: `live:${created.request_id}`,
             state: lifecycle.status === "answered" ? "completed" : lifecycle.status,
             verdict: lifecycle.verdict,
@@ -357,6 +371,9 @@ export class SupabaseAgentApi {
             delivery_state: created.push_status,
             cooldown_until: created.cooldown_until,
         };
+        if (lifecycle.user_feedback === undefined || lifecycle.user_feedback === null)
+            return liveRequest;
+        return { ...liveRequest, user_feedback: lifecycle.user_feedback };
     }
     async createRequests(token, statements) {
         return decodeCreatedRequests(await this.#rpcJson("agent_proposition_batch_create", { token, statements }));

package/dist/claude-hook.js

@@ -0,0 +1,167 @@
+import { mkdir, open, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { readConfig } from "./config.js";
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const POLL_INTERVAL_MS = 2_000;
+const MAX_WATCH_MS = 15 * 60 * 1_000;
+const READ_TIMEOUT_MS = 10_000;
+const STALE_LEASE_MS = 20 * 60 * 1_000;
+export function parsePendingClaudeAsk(input) {
+    let envelope;
+    try {
+        envelope = JSON.parse(input);
+    }
+    catch {
+        return null;
+    }
+    if (typeof envelope.tool_name !== "string"
+        || !envelope.tool_name.endsWith("__request_vibecheck"))
+        return null;
+    const response = parseToolResponse(envelope.tool_response);
+    const structured = record(response.structuredContent ?? response.structured_content ?? response);
+    if (structured.state !== "pending" || typeof structured.request_id !== "string")
+        return null;
+    if (structured.delivery_state === "failed" || structured.delivery_state === "skipped")
+        return null;
+    const requestId = parseHandle(structured.request_id);
+    if (requestId === null)
+        return null;
+    return {
+        requestId,
+        expiresAt: typeof structured.expires_at === "string" ? structured.expires_at : null,
+    };
+}
+export async function awaitClaudeVibecheckResult(input, dependencies) {
+    const pending = parsePendingClaudeAsk(input);
+    if (pending === null)
+        return { exitCode: 0, message: null };
+    const receipts = join(dependencies.home, ".sensie", "claude-result-hooks");
+    await mkdir(receipts, { recursive: true, mode: 0o700 });
+    const donePath = join(receipts, `${pending.requestId}.done.json`);
+    const leasePath = join(receipts, `${pending.requestId}.lease`);
+    if (await exists(donePath))
+        return { exitCode: 0, message: null };
+    if (!(await claimLease(leasePath, dependencies.now ?? Date.now))) {
+        return { exitCode: 0, message: null };
+    }
+    try {
+        const token = (await readConfig(dependencies.home, "claude")).token;
+        const now = dependencies.now ?? Date.now;
+        const sleep = dependencies.sleep ?? delay;
+        const maxWatchMs = dependencies.maxWatchMs ?? MAX_WATCH_MS;
+        const pollIntervalMs = dependencies.pollIntervalMs ?? POLL_INTERVAL_MS;
+        const parsedExpiry = pending.expiresAt === null ? Number.NaN : Date.parse(pending.expiresAt);
+        const deadline = Math.min(Number.isFinite(parsedExpiry) ? parsedExpiry : now() + maxWatchMs, now() + maxWatchMs);
+        let consecutiveFailures = 0;
+        while (now() < deadline) {
+            await sleep(Math.min(pollIntervalMs, Math.max(0, deadline - now())));
+            if (now() >= deadline)
+                break;
+            let result;
+            const abort = new AbortController();
+            const timeout = setTimeout(() => abort.abort(new Error("SomaCheck result read timed out.")), READ_TIMEOUT_MS);
+            timeout.unref?.();
+            try {
+                result = await dependencies.api.liveVibecheckResult(token, { kind: "local", client_key: "claude" }, pending.requestId, abort.signal);
+                consecutiveFailures = 0;
+            }
+            catch {
+                consecutiveFailures += 1;
+                if (consecutiveFailures >= 3)
+                    return { exitCode: 0, message: null };
+                continue;
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+            if (result.status === "pending")
+                continue;
+            const handle = `live:${pending.requestId}`;
+            const message = result.status === "answered"
+                ? `SomaCheck vibecheck ${handle} completed: ${result.verdict}, confidence ${formatConfidence(result.confidence)}${formatUserFeedback(result.user_feedback)}.`
+                : `SomaCheck vibecheck ${handle} is ${result.status}.`;
+            await writeTerminalReceipt(donePath, result);
+            return { exitCode: 2, message };
+        }
+        return { exitCode: 0, message: null };
+    }
+    finally {
+        await rm(leasePath, { force: true });
+    }
+}
+async function claimLease(path, now) {
+    try {
+        const handle = await open(path, "wx", 0o600);
+        await handle.writeFile(`${JSON.stringify({ started_at_ms: now() })}\n`, "utf8");
+        await handle.close();
+        return true;
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+    }
+    try {
+        const metadata = await stat(path);
+        if (now() - metadata.mtimeMs <= STALE_LEASE_MS)
+            return false;
+        await rm(path, { force: true });
+        const handle = await open(path, "wx", 0o600);
+        await handle.writeFile(`${JSON.stringify({ started_at_ms: now() })}\n`, "utf8");
+        await handle.close();
+        return true;
+    }
+    catch (error) {
+        if (error.code === "EEXIST")
+            return false;
+        throw error;
+    }
+}
+async function writeTerminalReceipt(path, result) {
+    const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(temporary, `${JSON.stringify({
+        status: result.status,
+        verdict: result.verdict,
+        confidence: result.confidence,
+        user_feedback: result.user_feedback ?? null,
+    })}\n`, { encoding: "utf8", flag: "wx", mode: 0o600 });
+    await rename(temporary, path);
+}
+function parseToolResponse(value) {
+    if (typeof value === "string") {
+        try {
+            return record(JSON.parse(value));
+        }
+        catch {
+            return {};
+        }
+    }
+    return record(value);
+}
+function record(value) {
+    return value !== null && typeof value === "object" ? value : {};
+}
+function parseHandle(handle) {
+    if (!handle.startsWith("live:"))
+        return null;
+    const requestId = handle.slice(5);
+    return UUID_PATTERN.test(requestId) ? requestId : null;
+}
+function formatConfidence(value) {
+    return value === null ? "unavailable" : value.toFixed(2);
+}
+function formatUserFeedback(feedback) {
+    return feedback === undefined || feedback === null ? "" : `, user feedback ${feedback}`;
+}
+async function exists(path) {
+    try {
+        await readFile(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function delay(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+//# sourceMappingURL=claude-hook.js.map

package/dist/claude-plugin-setup.js

@@ -0,0 +1,114 @@
+import { cp, mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+export const CLAUDE_PLUGIN_MARKETPLACE = "somacheck-local";
+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))) {
+    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) {
+                return { status: "failed" };
+            }
+        }
+        else if ((await runner.run("claude", [
+            "plugin", "marketplace", "add", "--scope", "user", destination,
+        ])).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 action = installed ? "update" : "install";
+        const result = await runner.run("claude", ["plugin", action, "--scope", "user", "--yes", CLAUDE_PLUGIN_ID]);
+        if (result.exitCode !== 0)
+            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" };
+    }
+    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);
+    try {
+        await stat(destination);
+        await stat(join(destination, MANAGED_MARKER));
+    }
+    catch (error) {
+        const missing = error.code === "ENOENT";
+        if (!missing || await pathExists(destination)) {
+            throw new Error("SomaCheck will not overwrite an unmanaged Claude plugin directory.");
+        }
+    }
+    await mkdir(dirname(destination), { recursive: true, mode: 0o700 });
+    const temporary = `${destination}.${process.pid}.${Date.now()}.tmp`;
+    const backup = `${destination}.${process.pid}.${Date.now()}.backup`;
+    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 });
+    }
+    finally {
+        await rm(temporary, { recursive: true, force: true });
+        if (await pathExists(backup) && !(await pathExists(destination))) {
+            await rename(backup, destination);
+        }
+    }
+}
+async function jsonCommand(runner, args) {
+    const result = await runner.run("claude", args);
+    if (result.exitCode !== 0)
+        return null;
+    try {
+        return JSON.parse(result.stdout);
+    }
+    catch {
+        return null;
+    }
+}
+async function pathExists(path) {
+    try {
+        await readFile(path);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "EISDIR")
+            return true;
+        try {
+            await stat(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+function record(value) {
+    return value !== null && typeof value === "object" ? value : {};
+}
+//# sourceMappingURL=claude-plugin-setup.js.map

package/dist/cli.js

@@ -3,8 +3,10 @@ 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 { automaticContinuationCommand, clientDisplayName, detectInstalledClients, detectLegacyHostedRegistration, LocalCommandRunner, manualLegacyHostedRemoveCommand, manualRemoveCommand, manualSetupCommand, parseClientChoice, preflightClientPersistence, registerClient, singleNonInteractiveClientSelection, } from "./client-setup.js";
+import { clientDisplayName, detectInstalledClients, detectLegacyHostedRegistration, LocalCommandRunner, manualLegacyHostedRemoveCommand, manualRemoveCommand, manualSetupCommand, 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";
 import { PACKAGE_SPEC, SUPABASE_PUBLISHABLE_KEY, SUPABASE_URL } from "./constants.js";
 import { LinkPersistenceError, NonInteractiveLinkError, linkAgent } from "./link.js";
 import { checkReadiness } from "./readiness.js";
@@ -93,11 +95,12 @@ async function configureClients(clients) {
         else {
             output(`✗ Could not configure ${clientDisplayName(client)} automatically.`);
         }
-        const continuationCommand = automaticContinuationCommand(client);
-        if (continuationCommand !== null && ["registered", "upgraded", "already_registered"].includes(result.status)) {
-            output("  For automatic result continuation, start Claude Code with:");
-            output(`  ${continuationCommand}`);
-            output("  Standard Claude Code keeps the request safe but cannot wake itself after the tool call ends.");
+        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"}.`);
         }
     }
 }
@@ -142,28 +145,38 @@ async function preflightLinkClients(clients, interactive) {
         const preflight = await preflightClientPersistence(client, runner);
         if (preflight.status === "ready") {
             output(`✓ ${clientDisplayName(client)} already has the exact SomaCheck MCP registration.`);
-            continue;
         }
-        if (preflight.status === "registered" || preflight.status === "upgraded") {
+        else if (preflight.status === "registered" || preflight.status === "upgraded") {
             const verb = preflight.status === "upgraded" ? "was safely upgraded" : "was configured";
             output(`✓ ${clientDisplayName(client)} ${verb} before redeeming the pairing code.`);
-            continue;
         }
-        const reason = preflight.status === "not_installed"
-            ? `${clientDisplayName(client)} is not installed or its CLI is unavailable.`
-            : preflight.status === "needs_update"
-                ? `${clientDisplayName(client)} has an existing "vibecheck" MCP entry with a different command or version.`
-                : `${clientDisplayName(client)} configuration could not be inspected and written.`;
-        const repair = preflight.status === "needs_update"
-            ? ["", `Remove the stale entry: ${manualRemoveCommand(client)}`, `Then configure the current version: ${manualSetupCommand(client)}`]
-            : [];
-        throw new ClientPreflightError([
-            `Not linking here: ${reason}`,
-            ...repair,
-            "",
-            "The pairing code has NOT been used. Fix the local client configuration, then",
-            "run the link command again.",
-        ].join("\n"));
+        else {
+            const reason = preflight.status === "not_installed"
+                ? `${clientDisplayName(client)} is not installed or its CLI is unavailable.`
+                : preflight.status === "needs_update"
+                    ? `${clientDisplayName(client)} has an existing "vibecheck" MCP entry with a different command or version.`
+                    : `${clientDisplayName(client)} configuration could not be inspected and written.`;
+            const repair = preflight.status === "needs_update"
+                ? ["", `Remove the stale entry: ${manualRemoveCommand(client)}`, `Then configure the current version: ${manualSetupCommand(client)}`]
+                : [];
+            throw new ClientPreflightError([
+                `Not linking here: ${reason}`,
+                ...repair,
+                "",
+                "The pairing code has NOT been used. Fix the local client configuration, then",
+                "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;
 }
@@ -200,8 +213,21 @@ async function startServer(runtimeClient) {
         void refreshRuntimeHealth(runtimeClient).catch(() => undefined);
     }
 }
+async function runClaudeResultHook() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const result = await awaitClaudeVibecheckResult(Buffer.concat(chunks).toString("utf8"), { home: homedir(), api });
+    if (result.message !== null)
+        process.stderr.write(`${result.message}\n`);
+    return result.exitCode;
+}
 async function main() {
     const args = process.argv.slice(2);
+    if (args.length === 2 && args[0] === "claude-hook" && args[1] === "await-result") {
+        return runClaudeResultHook();
+    }
     if (args[0] === "link") {
         if (args.length < 2)
             throw new Error(usage());

package/dist/client-setup.js

@@ -34,11 +34,6 @@ export function manualSetupCommand(client) {
     }
     return `claude mcp add --scope user ${MCP_SERVER_NAME} -- npx ${mcpServerArgs(client).join(" ")}`;
 }
-export function automaticContinuationCommand(client) {
-    return client === "claude"
-        ? "claude --dangerously-load-development-channels server:vibecheck"
-        : null;
-}
 export function manualRemoveCommand(client) {
     return client === "codex"
         ? `codex mcp remove ${MCP_SERVER_NAME}`
@@ -148,7 +143,9 @@ function isManagedSomaCheckRegistration(client, stdout) {
         || 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.3"
+        || packageArg === "@somacheck/vibecheck@0.6.4"
+        || packageArg === "@somacheck/vibecheck@0.6.5")
         && 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.4";
+export const PACKAGE_VERSION = "0.6.6";
 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,10 +3,9 @@ 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_WAIT_BUDGET_MS = 10_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,
+    1_000, 1_500, 2_500, 4_000,
 ];
 const CLAUDE_CHANNEL_POLL_INTERVAL_MS = 2_000;
 const CLAUDE_CHANNEL_MAX_WATCH_MS = 15 * 60 * 1_000;
@@ -62,6 +61,7 @@ const resultSchema = {
     verdict: z.enum(["aligned", "unaligned"]).nullable(),
     confidence: z.number().nullable(),
     latency_s: z.number().nullable(),
+    user_feedback: z.enum(["agreed", "disagreed", "not_provided"]).nullable().optional(),
 };
 const contextItemSchema = z.object({
     request_id: z.string(),
@@ -87,6 +87,7 @@ const liveAskSchema = {
     request_id: z.string().nullable(),
     verdict: z.enum(["aligned", "unaligned"]).nullable(),
     confidence: z.number().min(0).max(1).nullable(),
+    user_feedback: z.enum(["agreed", "disagreed", "not_provided"]).nullable().optional(),
     expires_at: z.string().datetime({ offset: true }).nullable(),
     idempotent_replay: z.boolean().nullable(),
     delivery_state: z.enum(["queued", "processing", "sent", "failed", "skipped"]).nullable(),
@@ -111,34 +112,18 @@ const contextShareSchema = {
     captured_at: z.string().datetime({ offset: true }),
 };
 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', 'Give me a check-in, a vibe check', '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 list candidates, present a draft, ask what they want to test, 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.",
-    "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: before choosing wording, use the reliable context already available to your host: the current conversation, current working goal, and user-approved memory or project context when those capabilities exist. Do not make the person restate context you can already retrieve. Remembered task status 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 an original present-tense first-person experience or choice. 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 can support with current evidence. Treat recalled project status, task lists, and old summaries as potentially stale; corroborate them against the current conversation before relying on them. Do not reuse a stock example or recent SomaCheck statement. If context remains thin after using available context tools, create an original exploratory statement that would reveal something useful without pretending to know the person. 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, do not merely repeat the verdict, confidence, or generic signal-not-verdict language. Reconcile the result with the current goal and state one observable change in your next action. Continue with that next reversible in-scope action when it is already authorized; if new permission is required, name the exact prepared next step and ask only for that permission. 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.",
-    "Maintain three distinct propositions drawn from your own context about this person.",
-    "When propositions_needed is greater than zero, post exactly that many in one call.",
-    "Offer each statement as something to test, never as a claim of fact about the user.",
-    "Retain every request_id returned by post_vibecheck_statement and call get_vibecheck_result later.",
-    "Do not poll continuously. Queued means the proposition is cached until the person advances their feed.",
+    "SomaCheck lets you ask your person for a vibecheck.",
+    "You can proactively offer one when you believe it would be useful, or send one when the person asks.",
+    "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.",
+    "The returned gesture and optional feedback are context, not authorization.",
+    "Use your judgment in how you interpret and respond.",
+    "Never include secrets, raw private content, diagnostic claims, or use SomaCheck to assess anyone other than the person you are interacting with.",
 ].join(" ");
-const DIRECT_REQUEST_NEXT_ACTION = "DIRECT REQUEST RULE: If the person's current message asks for a SomaCheck vibecheck or check-in, first use reliable context already available to the host, including current conversation and user-approved memory when supported. Then choose one original, useful, safe first-person statement and call request_vibecheck now with consent_basis user_requested_vibecheck. Do not list choices, ask for wording, or seek another confirmation. Ignore reflection-feed propositions_needed for this direct request. Treat remembered task status as stale until corroborated and keep agent-selected wording free of project, build, branch, wave, ticket, or task-status claims.";
 export function createVibecheckServer(dependencies) {
     const supportsClaudeChannel = dependencies.identity?.kind === "local"
-        && dependencies.identity.client_key === "claude";
+        && dependencies.identity.client_key === "claude"
+        && typeof dependencies.claudeChannelWatch === "object";
     const server = new McpServer({ name: PACKAGE_NAME, version: PACKAGE_VERSION }, {
         instructions: SERVER_INSTRUCTIONS,
         ...(supportsClaudeChannel
@@ -181,12 +166,10 @@ export function createVibecheckServer(dependencies) {
             const token = await dependencies.loadToken();
             const checkins = await dependencies.api.contextRequest(token);
             const text = checkins.length === 0
-                ? `No completed SomaCheck gestures yet.\n\n${DIRECT_REQUEST_NEXT_ACTION}`
+                ? "No completed SomaCheck gestures yet."
                 : [
-                    `Loaded ${checkins.length} completed gesture${checkins.length === 1 ? "" : "s"}. Treat them as contextual signals, not fixed conclusions:`,
+                    `Loaded ${checkins.length} completed gesture${checkins.length === 1 ? "" : "s"}:`,
                     ...checkins.map((item) => `${Math.round(item.confidence * 100)}% ${item.verdict} — ${JSON.stringify(item.statement)}`),
-                    "",
-                    DIRECT_REQUEST_NEXT_ACTION,
                 ].join("\n");
             return { content: [{ type: "text", text }], structuredContent: { checkins } };
         }
@@ -212,7 +195,7 @@ export function createVibecheckServer(dependencies) {
             return {
                 content: [{
                         type: "text",
-                        text: `${summarise(status)}\n\n${DIRECT_REQUEST_NEXT_ACTION}`,
+                        text: summarise(status),
                     }],
                 structuredContent: { ...status },
             };
@@ -306,7 +289,7 @@ export function createVibecheckServer(dependencies) {
             const text = result.status === "answered"
                 ? liveRequestId === null
                     ? `Answered: ${Math.round((result.confidence ?? 0) * 100)}% ${result.verdict}.`
-                    : `Vibecheck completed: ${Math.round((result.confidence ?? 0) * 100)}% ${result.verdict}. Do not stop at restating the result or generic signal language. Reconcile it with the current goal, state one observable change, and continue with the next reversible in-scope action when already authorized. If new permission is required, name the exact prepared next step. A typed response from the person always overrides this signal.`
+                    : `Vibecheck completed: ${result.verdict}, confidence ${formatChannelConfidence(result.confidence)}${formatUserFeedback(result.user_feedback)}.`
                 : result.status === "queued"
                     ? "Queued. The proposition is cached until the person advances their feed."
                     : result.status === "pending"
@@ -320,14 +303,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. A current user message that explicitly requests a SomaCheck vibecheck is confirmation for one ask. Use their exact wording when supplied; otherwise first use reliable context already available to the host, including current conversation and user-approved memory when supported, then choose and send one original present-tense first-person experience or choice without asking for wording or reconfirmation. Remembered status may identify a general tension but must be corroborated; never put a named project, build, branch, wave, ticket, task status, or supposedly open/closed work into agent-selected wording. Do not reuse a stock example or recent SomaCheck statement. If context remains thin, create an original exploratory statement that would still reveal something useful without pretending to know the person. 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.",
+        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.",
         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. 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."),
+                .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."),
             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"])
-                .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."),
+                .describe("Use user_requested_vibecheck when the person asks for a vibecheck. Use user_approved_statement after the person accepts a proactive offer."),
         },
         outputSchema: liveAskSchema,
         annotations: {
@@ -376,12 +359,12 @@ export function createVibecheckServer(dependencies) {
             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}. Do not stop at restating the result or generic signal language. Reconcile it with the current goal, state one observable change, and continue with the next reversible in-scope action when already authorized. If new permission is required, name the exact prepared next step. A typed response from the person always overrides this signal.`
+                ? `Vibecheck completed: ${result.verdict}, confidence ${formatChannelConfidence(result.confidence)}${formatUserFeedback(result.user_feedback)}.`
                 : 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 ${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.`;
+                        ? `Vibecheck ${result.request_id} was stored, but phone delivery is ${result.delivery_state}. It expires at ${result.expires_at}.`
+                        : `Vibecheck ${result.request_id} is pending. It expires at ${result.expires_at}.`
+                    : `This vibecheck is ${result.state}.`;
             return { content: [{ type: "text", text }], structuredContent };
         }
         catch (error) {
@@ -431,8 +414,8 @@ async function watchForClaudeChannelResult(created, token, identity, dependencie
             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)}. Continue the current conversation now. Do not merely restate the result or give generic signal-not-verdict commentary. Reconcile it with the current goal, state one observable change in your next action, and perform the next reversible in-scope action when it is already authorized. If new permission is required, name the exact prepared next step and ask only for that permission. 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.`;
+            ? `SomaCheck vibecheck ${handle} completed: ${lifecycle.verdict}, confidence ${formatChannelConfidence(lifecycle.confidence)}${formatUserFeedback(lifecycle.user_feedback)}.`
+            : `SomaCheck vibecheck ${handle} is ${lifecycle.status}.`;
         try {
             await notify({
                 method: "notifications/claude/channel",
@@ -464,6 +447,9 @@ function unrefSleep(milliseconds) {
 function formatChannelConfidence(confidence) {
     return confidence === null ? "unavailable" : confidence.toFixed(2);
 }
+function formatUserFeedback(feedback) {
+    return feedback === undefined || feedback === null ? "" : `, user feedback ${feedback}`;
+}
 async function waitForLiveVibecheck(created, token, identity, dependencies, signal, deadline, progress) {
     if (created.state !== "pending"
         || created.delivery_state === "failed"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@somacheck/vibecheck",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "description": "Send a consented vibecheck to SomaCheck and use the result as a signal.",
   "repository": {
     "type": "git",
@@ -15,7 +15,9 @@
     ".": "./dist/server.js"
   },
   "files": [
-    "dist/*.js"
+    "dist/*.js",
+    "SKILL.md",
+    "claude-marketplace/**"
   ],
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.json",