@somacheck/vibecheck 0.6.4 → 0.6.5

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.5 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.5 setup codex
+npx -y @somacheck/vibecheck@0.6.5 setup claude
+npx -y @somacheck/vibecheck@0.6.5 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.5", "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.5 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
@@ -191,34 +194,26 @@ 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
+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.
+After a completed result, use it as context and respond naturally in the
+current conversation. The result is not authorization and does not establish a
+diagnosis or certainty. Never say that the person's body made the decision.
 
 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,157 @@
+---
+name: vibecheck
+description: Request or offer a SomaCheck vibecheck at useful moments without nagging.
+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
+
+Use SomaCheck through one of two entry points:
+
+1. **The person asks for a vibecheck.** Select and send one useful statement immediately. Their current request is consent for one ask. Do not make them supply wording or confirm again.
+2. **You notice one of the three trigger events below.** Offer one exact statement and wait for acceptance before sending it.
+
+A vibecheck tests a first-person statement through the linked `@somacheck/vibecheck` MCP server. It does not diagnose the person, decide for them, or authorize an action.
+
+## Direct requests
+
+When the current message explicitly asks for a SomaCheck vibecheck or check-in (including phrasing such as "give me a check-in, a vibe check"), call `request_vibecheck` in that same turn with `consent_basis: "user_requested_vibecheck"`.
+
+- If the person supplied exact wording, preserve it.
+- Otherwise choose one present-tense, first-person statement about a current experience, choice, or tension.
+- First use reliable context already available to the host: the current conversation, current goal, and user-approved memory or project context when those capabilities exist. Do not ask the person to restate context you can retrieve.
+- Treat remembered project status, task lists, and summaries as potentially stale. They may identify a general tension, but the statement must not name a project, build, branch, wave, ticket, task status, or supposedly open or closed work.
+- Corroborate remembered status against the current conversation. Do not reuse a stock template or recent SomaCheck statement. If context remains thin, create an original exploratory statement that can reveal something useful without pretending to know the person.
+- Generate one fresh UUID for `idempotency_key`. Reuse it only to retry the same exact statement.
+- Do not list candidates, present a draft, ask what they want to test, or ask "Want me to send it?" The request already supplied one-ask consent.
+
+## When to offer
+
+A trigger is an event, not every message that matches a keyword. Once you have offered for an event, treat it as consumed until the task, decision, or message pattern meaningfully changes.
+
+### Trigger 1: Drift
+
+Offer when at least one of these transcript-grounded conditions is true:
+
+- Transcript timestamps show 90 minutes or more on the same task or thread without reaching the stated outcome.
+- The same or materially equivalent fix has been attempted three or more times.
+- The current work no longer advances the human's stated goal, and the human has not explicitly changed that goal.
+
+Stay quiet during productive deep work, after an explicit goal change, or when duration cannot be established. A long message by itself is not drift.
+
+### Trigger 2: Major or irreversible decision ahead
+
+Offer immediately before a consequential action when the transcript shows that action is imminent. Examples include deploying to production, sending an important email or offer, signing an agreement, deleting data, making a material purchase, hiring or firing, or saying "just do it" about a consequential step.
+
+Planning or discussing a possible decision is not enough. The action must be close enough that a pause now could still affect it. This trigger may bypass a decline cooldown from triggers 1 or 3, but it still must pass the live status gate.
+
+### Trigger 3: Stress signals in messages
+
+Offer when the recent messages contain either two or more signals in a short span, or one strong pattern repeated across retries:
+
+- Cursing about the task or situation.
+- Fragmented, rushed, or unusually incoherent instructions.
+- All-caps urgency that is not an acronym, log, or quoted text.
+- Repeated retry commands with no meaningful change in approach.
+- Phrases such as "whatever, just make it work."
+
+Describe only the observable message pattern. Do not claim to know how the person feels. One casual swear, terse normal writing, pasted logs, or quoted all-caps text is not enough.
+
+### Multiple triggers
+
+Choose one primary trigger per event. Use trigger 2 first when an imminent consequential action exists, then trigger 3, then trigger 1. Do not stack or repeat offers.
+
+## Proactive offer sequence
+
+1. If no trigger fired, do nothing.
+2. Check the local event and cooldown record. If this event was already offered, stay quiet. If a trigger 1 or 3 offer was declined within the last two hours, stay quiet. A new trigger 2 event may bypass that cooldown.
+3. Call `get_vibecheck_status` before showing an offer.
+4. Stay quiet when `has_pending_request` is true. Reflection-feed cadence and capacity, including `cadence.may_create_now` and `propositions_needed`, do not authorize or block a live vibecheck.
+5. Make one short offer containing one statement to test. Do not post yet.
+6. If the human declines or does not accept, record the event as offered. For a decline, start a two-hour cooldown for triggers 1 and 3.
+7. If the human accepts, call `request_vibecheck` once with the exact offered statement, a fresh UUID in `idempotency_key`, and `consent_basis: "user_approved_statement"`.
+8. If the call must be retried, preserve both the exact statement and the same idempotency key.
+
+`get_vibecheck_context` is optional before phrasing an offer. Use it only to avoid repeating a recent statement. Do not call `share_somacheck_context` or `post_vibecheck_statement` in this workflow. Live vibechecks and the asynchronous reflection feed are separate product behaviors.
+
+## How to phrase the offer
+
+Use a statement to test, never a claim about the person. Keep it first-person, present-tense, neutral, and focused on one decision or next step. Do not include raw transcript text, names, secrets, identifiers, customer data, or private details.
+
+Good offer forms:
+
+- "Before you ship, want to test: 'I am ready to deploy this to production'?"
+- "Quick 3-second check: 'I trust this decision'?"
+- "Before another retry, want to test: 'This next attempt is meaningfully different from the last one'?"
+
+Do not say that the person is distracted, stressed, dysregulated, afraid, or certain. Do not use medical language. Do not say "vibecheck confirms" or "vibecheck proves." Do not use an em dash in any human-facing string.
+
+### Drift statement templates
+
+1. "I am still working on the right problem."
+2. "This next attempt is meaningfully different from the last one."
+3. "I know what outcome I am trying to reach."
+4. "Continuing this task now is the best use of my attention."
+5. "I am ready to pause and restate the goal."
+6. "The current approach is moving me closer to done."
+7. "I have enough context to keep going."
+8. "I want to keep working on this thread."
+9. "A short reset would help me choose the next step."
+
+### Major or irreversible decision statement templates
+
+1. "I am ready to deploy this to production."
+2. "I trust this decision."
+3. "I am ready to send this message as written."
+4. "I understand the consequences of this action."
+5. "I have the information I need to commit."
+6. "This purchase is the right choice right now."
+7. "I am ready to make this offer."
+8. "I am comfortable making this change irreversible."
+9. "I want to act on this now."
+
+### Stress-signal statement templates
+
+1. "I want to keep pushing on this right now."
+2. "I trust the next step I am about to take."
+3. "I have enough clarity to choose the next step."
+4. "I am ready to slow down for one minute."
+5. "This approach still feels right to me."
+6. "I want to send this message in this tone."
+7. "I am comfortable continuing without another review."
+8. "I know what I need from this task."
+9. "I want to make this decision now."
+
+Adapt a template only enough to make it relevant. Keep the statement free of sensitive specifics.
+
+## Cooldown rules
+
+- One offer per trigger event, whether accepted, declined, or ignored.
+- After a decline, suppress trigger 1 and trigger 3 offers for two hours.
+- A new imminent trigger 2 event may bypass that two-hour cooldown.
+- The one-pending gate always wins. A completed, expired, or cancelled request has no server cooldown; a new direct user request may be sent immediately.
+- A continued conversation about the same task or decision is not a new event. A materially new goal, a different consequential action, or a new message-pattern episode can be.
+
+## What to do with the result
+
+`request_vibecheck` waits boundedly for the exact result. If it returns `completed`, use the result as context and respond naturally in the current conversation. The result is not authorization and does not establish a diagnosis or certainty. If the tool returns `pending`, retain the exact `live:<uuid>` handle. Do not promise that you will check back automatically unless the current host supports automatic result delivery. Use `get_vibecheck_result` once when the person asks or at a natural follow-up. Never create a replacement request and never poll in a tight loop.
+
+For `expired` or `cancelled`, do not infer an answer and do not immediately repost.
+
+A result never grants permission to deploy, send, sign, delete, spend, hire, fire, publish, or take any other consequential action.
+
+## Do not
+
+- Do not offer without one of the three transcript-grounded triggers.
+- Do not ignore or reconfirm an explicit request for one vibecheck.
+- Do not claim to know the person's internal state.
+- Do not nag, stack offers, or re-offer for the same event.
+- Do not proactively offer when a request is pending.
+- Do not send an unsolicited offer before the human accepts the exact statement.
+- Do not use `post_vibecheck_statement` for a live ask.
+- Do not send raw conversation text, secrets, identifiers, or private details to the server.
+- Do not call `share_somacheck_context` in this workflow.
+- Do not treat any outcome as fact, diagnosis, proof, or authorization.
+- Do not continuously poll for a result.
+- Do not use medical language or an em dash in a human-facing string.

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.5",
+      "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.5",
+  "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.5 claude-hook await-result",
+            "asyncRewake": true,
+            "timeout": 900
+          }
+        ]
+      }
+    ]
+  }
+}

package/dist/claude-hook.js

@@ -0,0 +1,152 @@
+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 = record(envelope.tool_response);
+    const structured = record(response.structuredContent ?? response.structured_content);
+    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 result for ${handle}: ${result.verdict} (confidence ${formatConfidence(result.confidence)}). Use it as context in the current conversation. It is not authorization and does not establish a diagnosis or certainty.`
+                : `SomaCheck request ${handle} is ${result.status}. Do not infer an answer or create a replacement request for the same decision.`;
+            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,
+    })}\n`, { encoding: "utf8", flag: "wx", mode: 0o600 });
+    await rename(temporary, path);
+}
+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);
+}
+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,8 @@ 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")
         && 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.5";
 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;
@@ -124,9 +123,9 @@ const SERVER_INSTRUCTIONS = [
     "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.",
+    "request_vibecheck waits boundedly for the exact answer. If it returns completed, use the result as context in the current conversation. 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 unless the host has automatic result delivery. Continue automatically only after an actual result event arrives for that exact request.",
+    "After a completed result, use it as context in the current conversation and respond naturally. It is not authorization and does not establish a diagnosis or certainty. Do not claim the person's body decided anything.",
     "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.",
@@ -306,7 +305,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: ${Math.round((result.confidence ?? 0) * 100)}% ${result.verdict}. Use it as context in the current conversation. It is not authorization and does not establish a diagnosis or certainty.`
                 : result.status === "queued"
                     ? "Queued. The proposition is cached until the person advances their feed."
                     : result.status === "pending"
@@ -376,11 +375,11 @@ 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: ${Math.round((result.confidence ?? 0) * 100)}% ${result.verdict}. Use it as context in the current conversation. It is not authorization and does not establish a diagnosis or certainty.`
                 : 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.`
+                        : `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 the host delivers an actual result event.`
                     : `This vibecheck is ${result.state}. Do not create another ask for the same decision.`;
             return { content: [{ type: "text", text }], structuredContent };
         }
@@ -431,7 +430,7 @@ 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 has completed. The exact result is ${lifecycle.verdict} with confidence ${formatChannelConfidence(lifecycle.confidence)}. Use it as context in the current conversation. It is not authorization and does not establish a diagnosis or certainty. 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({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@somacheck/vibecheck",
-  "version": "0.6.4",
+  "version": "0.6.5",
   "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",