@linghun/tui 0.1.0

package/dist/chunk-CFXB5SE5.js

@@ -0,0 +1,502 @@
+// src/remote-inbound-bridge-runtime.ts
+import { createHash } from "crypto";
+import { randomBytes } from "crypto";
+function getRemoteBridgeDoctor(remote, channelId, now = /* @__PURE__ */ new Date()) {
+  const channel = remote.channels.find((item) => item.id === normalizeBridgeChannelId(channelId));
+  if (!channel) {
+    return {
+      channel: channelId,
+      platform: "feishu",
+      readiness: "needs-app-setup",
+      capabilities: ["notification-only"],
+      now: now.toISOString(),
+      canRunLocalFixture: false,
+      inboundPath: "unknown channel",
+      nextAction: "Run /remote bridge doctor feishu|dingtalk|wecom.",
+      missing: ["known channel"]
+    };
+  }
+  return describeBridgeChannel(channel, now);
+}
+function formatRemoteBridgeDoctor(report) {
+  return [
+    `Remote bridge doctor\uFF1A${report.channel}`,
+    `- now: ${report.now}`,
+    `- readiness: ${report.readiness}`,
+    `- capabilities: ${report.capabilities.join(", ")}`,
+    `- inbound path: ${report.inboundPath}`,
+    `- local fixture: ${report.canRunLocalFixture ? "available" : "not available"}`,
+    `- missing: ${report.missing.length ? report.missing.join(", ") : "none"}`,
+    `- next: ${report.nextAction}`,
+    "- webhook path remains notification-only; fixture PASS is not real mobile inbound."
+  ].join("\n");
+}
+function createSignedRemoteInboundFixture(channel, input) {
+  const nowMs = input.nowMs ?? Date.now();
+  const messageId = input.messageId ?? `fixture-${channel.id}-${input.kind}`;
+  const nonce = input.nonce ?? stableFixtureNonce(channel.id, input.kind, messageId);
+  return {
+    kind: input.kind,
+    channel: channel.id,
+    messageId,
+    nonce,
+    source: channel.config.trustedSources[0] ?? `${channel.id}-fixture-source`,
+    bindingUserId: channel.config.bindingUserId ?? `${channel.id}-fixture-user`,
+    bindingDeviceId: channel.config.bindingDeviceId,
+    signature: `mock:inbound:${messageId}:${nonce}`,
+    expiresAt: new Date(nowMs + 6e4).toISOString(),
+    receivedAt: new Date(nowMs).toISOString(),
+    origin: "fixture",
+    eventId: input.eventId,
+    approve: input.approve,
+    text: input.text
+  };
+}
+function createRemotePairing(remote, channel, projectPath, sessionId, nowMs = Date.now(), code = createPairingCode()) {
+  const pairing = {
+    code,
+    channel: channel.id,
+    source: `${channel.id}-pairing`,
+    projectPath,
+    sessionId,
+    createdAt: new Date(nowMs).toISOString(),
+    expiresAt: new Date(nowMs + 5 * 60 * 1e3).toISOString(),
+    consumedMessageIds: [],
+    status: "pending"
+  };
+  remote.pairings = [pairing, ...remote.pairings.filter((item) => item.status === "pending")].slice(
+    0,
+    5
+  );
+  return {
+    status: "created",
+    summary: `remote pairing code created for ${channel.id}`,
+    pairing,
+    qr: `linghun://remote-bind?channel=${encodeURIComponent(channel.id)}&code=${code}`,
+    fallback: `/bind ${code}`
+  };
+}
+function formatRemotePairing(pairing) {
+  if (pairing.status !== "created") {
+    return pairing.summary;
+  }
+  return [
+    `Remote pairing\uFF1A${pairing.pairing.channel}`,
+    `- code: ${pairing.pairing.code}`,
+    `- expiresAt: ${pairing.pairing.expiresAt}`,
+    `- phone fallback: ${pairing.fallback}`,
+    `- QR payload: ${pairing.qr}`,
+    "- QR render: not available in this terminal; please copy the fallback command.",
+    "- webhook URL / secret / endpoint are not included."
+  ].join("\n");
+}
+function formatRemotePairingStatus(remote) {
+  const active = remote.pairings.filter((item) => item.status === "pending");
+  if (active.length === 0) return "Remote pairing\uFF1Ano active pairing code.";
+  return [
+    "Remote pairing status",
+    ...active.map(
+      (item) => `- ${item.channel}: ${item.code}; expiresAt=${item.expiresAt}; source=${item.source}`
+    )
+  ].join("\n");
+}
+function cancelRemotePairing(remote, channelId) {
+  const normalized = channelId ? normalizeBridgeChannelId(channelId) : void 0;
+  const target = remote.pairings.find(
+    (item) => item.status === "pending" && (!normalized || item.channel === normalized)
+  );
+  if (!target) return { status: "unknown", summary: "no active pairing code to cancel" };
+  target.status = "cancelled";
+  return { status: "cancelled", summary: `remote pairing cancelled for ${target.channel}` };
+}
+function processRemoteBindCommand(remote, channel, message, nowMs = Date.now()) {
+  if (!parseBindCode(message.text ?? "")) return void 0;
+  const validation = validateRemotePairingCode(remote, channel, message, nowMs);
+  if (validation.status !== "valid") return validation;
+  const pairing = validation.pairing;
+  pairing.consumedMessageIds.unshift(message.messageId);
+  pairing.status = "bound";
+  channel.config.bindingUserId = message.bindingUserId;
+  if (message.bindingDeviceId) channel.config.bindingDeviceId = message.bindingDeviceId;
+  if (!channel.config.trustedSources.includes(message.source)) {
+    channel.config.trustedSources.push(message.source);
+  }
+  channel.runtimeStatus = "ready";
+  channel.bindingStatus = "bound";
+  channel.lastError = void 0;
+  channel.nextAction = `/remote bridge test-inbound ${channel.id}`;
+  return {
+    status: "bound",
+    summary: "remote pairing bound; mobile control remains summary-only and permission-aware",
+    pairing
+  };
+}
+function validateRemotePairingCode(remote, channel, message, nowMs = Date.now()) {
+  const code = parseBindCode(message.text ?? "");
+  const pairing = code ? remote.pairings.find((item) => item.code === code && item.status !== "cancelled") : void 0;
+  if (!pairing) return { status: "unknown", summary: "pairing code is unknown" };
+  if (pairing.status !== "pending") {
+    return { status: "replayed", summary: "pairing code was already used" };
+  }
+  if (pairing.channel !== channel.id) {
+    return { status: "channel_mismatch", summary: "pairing code belongs to another channel" };
+  }
+  if (Date.parse(pairing.expiresAt) <= nowMs) {
+    pairing.status = "expired";
+    return { status: "expired", summary: "pairing code expired" };
+  }
+  if (pairing.consumedMessageIds.includes(message.messageId)) {
+    return { status: "replayed", summary: "pairing bind message replayed" };
+  }
+  return { status: "valid", pairing };
+}
+function decideRemoteInbox(remote, message, turn, nowMs = Date.now()) {
+  if (message.kind === "status_query") {
+    return { status: "status_only", summary: formatRemoteStatusSummary(remote, turn) };
+  }
+  if (message.kind === "approval_response") {
+    return { status: "approval_only", message };
+  }
+  const text = (message.text ?? "").trim();
+  const busy = Boolean(
+    turn.activeModelTurn || turn.activeJob || turn.toolRunning || turn.pendingApproval
+  );
+  if (!busy) {
+    return { status: "route", reason: "idle", message };
+  }
+  const priority = hasInterruptIntent(text) ? "interrupt" : "normal";
+  const item = {
+    id: `rinbox-${stableFixtureNonce(message.channel, message.kind, message.messageId)}`,
+    channel: message.channel,
+    messageId: message.messageId,
+    source: message.source,
+    bindingUserId: message.bindingUserId,
+    text,
+    priority,
+    reason: priority === "interrupt" ? "explicit interrupt intent" : "active local turn",
+    createdAt: new Date(nowMs).toISOString(),
+    sessionId: turn.sessionId
+  };
+  remote.inbox.unshift(item);
+  remote.inbox = remote.inbox.slice(0, 20);
+  return { status: "queued", reason: item.reason, item };
+}
+function formatRemoteInbox(remote) {
+  if (remote.inbox.length === 0) return "Remote inbox\uFF1Aempty.";
+  return [
+    "Remote inbox\uFF08summary-only\uFF09",
+    ...remote.inbox.slice(0, 20).map(
+      (item) => `- ${item.id}: ${item.channel}; priority=${item.priority}; source=${item.source}; text=${redactMobileText(item.text)}`
+    )
+  ].join("\n");
+}
+function clearRemoteInbox(remote) {
+  const count = remote.inbox.length;
+  remote.inbox = [];
+  return count;
+}
+function rejectRemoteInboxItem(remote, id) {
+  const before = remote.inbox.length;
+  remote.inbox = remote.inbox.filter((item) => item.id !== id);
+  return remote.inbox.length !== before;
+}
+function drainRemoteInbox(remote) {
+  const drained = [...remote.inbox].reverse();
+  remote.inbox = [];
+  return drained;
+}
+function formatRemoteStatusSummary(remote, turn) {
+  const busy = Boolean(turn.activeModelTurn || turn.activeJob || turn.toolRunning);
+  return [
+    `Linghun / remote / ${busy ? "busy" : "idle"}`,
+    `status_query \xB7 pendingApproval=${turn.pendingApproval ? "yes" : "no"} \xB7 inbox=${remote.inbox.length}`,
+    `Next: ${busy ? "wait or send explicit interrupt" : "send a short instruction"}`
+  ].join("\n");
+}
+function feishuBridgeAdapter(event) {
+  return adaptBridgeEvent(event, "feishu");
+}
+function feishuReceiveMessageToBridgeEvent(event, nowMs = Date.now()) {
+  const messageId = event.message?.message_id;
+  const senderId = event.sender?.sender_id;
+  const source = senderId?.open_id ?? senderId?.user_id ?? senderId?.union_id;
+  if (!messageId) {
+    throw new Error("Feishu receive message event missing message_id");
+  }
+  if (!source) {
+    throw new Error("Feishu receive message event missing sender id");
+  }
+  const text = parseFeishuTextContent(event.message?.content);
+  return {
+    platform: "feishu",
+    source,
+    userId: source,
+    kind: classifyFeishuInboundKind(text),
+    text,
+    approve: classifyFeishuApprove(text),
+    eventId: parseFeishuApprovalEventId(text),
+    messageId,
+    nonce: event.event_id ?? messageId,
+    signature: "ref:feishu-long-connection",
+    expiresAt: new Date(nowMs + 6e4).toISOString(),
+    receivedAt: new Date(nowMs).toISOString()
+  };
+}
+function dingtalkBridgeAdapter(event) {
+  return adaptBridgeEvent(event, "dingtalk");
+}
+function dingtalkStreamFrameToBridgeEvent(frame, nowMs = Date.now()) {
+  const topic = frame.headers?.topic;
+  if (topic !== "/v1.0/im/bot/messages/get") {
+    throw new Error("DingTalk Stream frame topic is not a bot message");
+  }
+  const data = parseDingTalkStreamData(frame.data);
+  const messageId = stringValue(data.msgId) ?? frame.headers?.messageId;
+  const source = stringValue(data.senderId) ?? stringValue(data.senderStaffId);
+  if (!messageId) {
+    throw new Error("DingTalk Stream bot message missing msgId");
+  }
+  if (!source) {
+    throw new Error("DingTalk Stream bot message missing sender id");
+  }
+  const text = typeof data.text?.content === "string" ? data.text.content.trim() : "";
+  return {
+    platform: "dingtalk",
+    source,
+    userId: source,
+    kind: classifyPlainTextInboundKind(text),
+    text,
+    approve: classifyPlainTextApprove(text),
+    eventId: parsePlainTextApprovalEventId(text),
+    messageId,
+    nonce: frame.headers?.messageId ?? messageId,
+    signature: "ref:dingtalk-stream",
+    expiresAt: new Date(nowMs + 6e4).toISOString(),
+    receivedAt: new Date(nowMs).toISOString()
+  };
+}
+function wecomBridgeAdapter(event) {
+  return adaptBridgeEvent(event, "wecom");
+}
+function adaptBridgeEvent(event, expectedPlatform) {
+  if (event.platform !== expectedPlatform) {
+    throw new Error(`remote bridge adapter expected ${expectedPlatform}`);
+  }
+  return {
+    kind: event.kind,
+    channel: normalizeBridgeChannelId(expectedPlatform),
+    messageId: event.messageId,
+    nonce: event.nonce,
+    source: event.source,
+    bindingUserId: event.userId,
+    bindingDeviceId: event.deviceId,
+    signature: event.signature,
+    expiresAt: event.expiresAt,
+    receivedAt: event.receivedAt,
+    origin: "adapter",
+    eventId: event.eventId,
+    approve: event.approve,
+    text: event.text
+  };
+}
+function describeBridgeChannel(channel, now) {
+  const missing = bridgeMissingFields(channel);
+  const webhookOnly = channel.config.transport === "webhook" || channel.config.transport === "webhook_mock";
+  if (webhookOnly) {
+    return baseReport(channel, now, {
+      readiness: "notification-only",
+      capabilities: ["notification-only"],
+      canRunLocalFixture: false,
+      inboundPath: "outbound webhook only",
+      missing,
+      nextAction: "Use webhook for short status notifications only; configure an official app/CLI bridge for inbound."
+    });
+  }
+  const capabilities = platformBridgeCapabilities(channel.config.type);
+  const needsApp = missing.some((item) => item.includes("credentials")) || missing.includes("trusted source");
+  const needsDaemon = isFeishuLongConnection(channel) ? false : channel.config.inboundMode === "poll" ? !channel.config.cliPath : channel.config.inboundMode === "callback" && !channel.config.callbackEndpoint;
+  const readiness = needsApp ? platformNeedsAppReadiness(channel.config.type) : needsDaemon ? "needs-daemon" : isFeishuLongConnection(channel) ? "ready-to-start" : "fixture-ready";
+  return baseReport(channel, now, {
+    readiness,
+    capabilities,
+    canRunLocalFixture: !needsApp,
+    inboundPath: bridgeInboundPath(channel),
+    missing,
+    nextAction: bridgeNextAction(channel, readiness)
+  });
+}
+function baseReport(channel, now, partial) {
+  return {
+    channel: channel.id,
+    platform: channel.config.type,
+    now: now.toISOString(),
+    ...partial
+  };
+}
+function bridgeMissingFields(channel) {
+  const missing = [];
+  const config = channel.config;
+  if (!config.bindingUserId) missing.push("binding user");
+  if (config.trustedSources.length === 0) missing.push("trusted source");
+  if (config.transport === "official_cli" && !config.cliPath) missing.push("cli path");
+  if (config.transport === "official_cli" && (!config.inboundMode || config.inboundMode === "none")) {
+    missing.push("inbound mode");
+  }
+  if (config.inboundMode === "callback" && !config.callbackEndpoint)
+    missing.push("callback endpoint");
+  if (config.type === "feishu" || config.type === "lark") {
+    if (!config.appIdRef || !config.appSecretRef) missing.push("app credentials");
+    if (config.inboundMode === "callback" && config.callbackEndpoint !== "feishu-long-connection" && (!config.encryptKeyRef || !config.verificationTokenRef)) {
+      missing.push("callback verification refs");
+    }
+  }
+  if (config.type === "dingtalk" && !config.appIdRef && !config.tokenRef) {
+    missing.push("dingtalk app credentials");
+  }
+  if ((config.type === "wecom" || config.type === "enterprise-wechat") && !config.appIdRef && !config.tokenRef) {
+    missing.push("wecom app credentials");
+  }
+  return [...new Set(missing)];
+}
+function platformBridgeCapabilities(type) {
+  if (type === "feishu" || type === "lark") {
+    return ["full-mobile-control-capable", "app-callback-capable"];
+  }
+  if (type === "dingtalk") {
+    return ["approval-capable", "stream-callback-capable"];
+  }
+  return ["natural-language-inbound-capable", "app-callback-capable"];
+}
+function bridgeInboundPath(channel) {
+  if (channel.config.inboundMode === "callback") {
+    return channel.config.callbackEndpoint ? "app callback endpoint configured" : "app callback endpoint needed";
+  }
+  if (channel.config.inboundMode === "poll") {
+    return channel.config.localBridgePort ? `local bridge daemon on port ${channel.config.localBridgePort}` : "official CLI poll/stream daemon needed";
+  }
+  return "inbound disabled";
+}
+function bridgeNextAction(channel, readiness) {
+  if (readiness === "fixture-ready") {
+    return `/remote bridge test-inbound ${channel.id}; real mobile inbound still needs platform credentials and callback/daemon.`;
+  }
+  if (readiness === "ready-to-start") {
+    return `/remote bridge start ${channel.id}`;
+  }
+  if (readiness === "needs-daemon") {
+    return "Start/configure the official CLI poll/stream daemon or provide a callback endpoint.";
+  }
+  if (readiness === "needs-app-setup") {
+    return "Configure Feishu/Lark app refs and an inbound path before full mobile control is ready.";
+  }
+  if (readiness === "needs-dingtalk-app") {
+    return "Configure a DingTalk app/Stream callback before approval inbound is ready.";
+  }
+  if (readiness === "needs-wecom-app") {
+    return "Configure a WeCom app callback before natural-language inbound is ready.";
+  }
+  return "Keep webhook as notification-only.";
+}
+function isFeishuLongConnection(channel) {
+  return (channel.config.type === "feishu" || channel.config.type === "lark") && channel.config.transport === "official_cli" && channel.config.inboundMode === "callback" && channel.config.callbackEndpoint === "feishu-long-connection";
+}
+function platformNeedsAppReadiness(type) {
+  if (type === "dingtalk") return "needs-dingtalk-app";
+  if (type === "wecom" || type === "enterprise-wechat") return "needs-wecom-app";
+  return "needs-app-setup";
+}
+function normalizeBridgeChannelId(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "lark") return "feishu";
+  if (normalized === "enterprise-wechat") return "wecom";
+  return normalized;
+}
+function parseFeishuTextContent(content) {
+  if (!content) return "";
+  try {
+    const parsed = JSON.parse(content);
+    return typeof parsed.text === "string" ? parsed.text.trim() : "";
+  } catch {
+    return "";
+  }
+}
+function classifyFeishuInboundKind(text) {
+  return classifyPlainTextInboundKind(text);
+}
+function classifyPlainTextInboundKind(text) {
+  const normalized = text.trim().toLowerCase();
+  if (normalized === "\u72B6\u6001" || normalized === "status" || normalized === "/status") {
+    return "status_query";
+  }
+  if (/^(approve|deny)\b/i.test(normalized)) {
+    return "approval_response";
+  }
+  return "natural_language_message";
+}
+function classifyFeishuApprove(text) {
+  return classifyPlainTextApprove(text);
+}
+function classifyPlainTextApprove(text) {
+  if (/^approve\b/i.test(text.trim())) return true;
+  if (/^deny\b/i.test(text.trim())) return false;
+  return void 0;
+}
+function parseFeishuApprovalEventId(text) {
+  return parsePlainTextApprovalEventId(text);
+}
+function parsePlainTextApprovalEventId(text) {
+  const match = text.trim().match(/(?:event|eventId|approval)[:=]\s*([A-Za-z0-9_-]+)/i);
+  return match?.[1];
+}
+function parseDingTalkStreamData(data) {
+  if (!data) return {};
+  if (typeof data === "string") {
+    const parsed = JSON.parse(data);
+    return parsed;
+  }
+  return data;
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function createPairingCode() {
+  const alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+  const bytes = randomBytes(6);
+  return Array.from(bytes, (byte) => alphabet[byte % alphabet.length]).join("");
+}
+function parseBindCode(text) {
+  const match = text.trim().match(/^\/bind\s+([A-Z0-9]{6})$/i);
+  return match?.[1]?.toUpperCase();
+}
+function hasInterruptIntent(text) {
+  return /插队|立即处理|暂停当前任务|interrupt/i.test(text);
+}
+function redactMobileText(text) {
+  return text.replace(/(secret|token|api[_-]?key|authorization)\s*[:=]\s*\S+/gi, "$1=[REDACTED]");
+}
+function stableFixtureNonce(channelId, kind, messageId) {
+  return createHash("sha256").update(`${channelId}:${kind}:${messageId}`).digest("hex").slice(0, 16);
+}
+
+export {
+  getRemoteBridgeDoctor,
+  formatRemoteBridgeDoctor,
+  createSignedRemoteInboundFixture,
+  createRemotePairing,
+  formatRemotePairing,
+  formatRemotePairingStatus,
+  cancelRemotePairing,
+  processRemoteBindCommand,
+  validateRemotePairingCode,
+  decideRemoteInbox,
+  formatRemoteInbox,
+  clearRemoteInbox,
+  rejectRemoteInboxItem,
+  drainRemoteInbox,
+  formatRemoteStatusSummary,
+  feishuBridgeAdapter,
+  feishuReceiveMessageToBridgeEvent,
+  dingtalkBridgeAdapter,
+  dingtalkStreamFrameToBridgeEvent,
+  wecomBridgeAdapter
+};

package/dist/chunk-CRQORMFF.js

@@ -0,0 +1,32 @@
+import {
+  createShellTheme
+} from "./chunk-GC55DMZV.js";
+import {
+  fitText
+} from "./chunk-APJIC2O5.js";
+
+// src/shell/components/TaskSuggestionBar.tsx
+import { Box, Text } from "@linghun/ink-runtime";
+import { jsx } from "react/jsx-runtime";
+function TaskSuggestionBar({
+  suggestions,
+  cursor,
+  width,
+  noColor
+}) {
+  if (!suggestions || suggestions.length === 0) return null;
+  const theme = createShellTheme(noColor);
+  const innerWidth = Math.max(20, width - 4);
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", paddingX: 2, marginTop: 1, children: suggestions.map((s, index) => {
+    const cmd = s.action.kind === "slash" ? s.action.command : "";
+    const marker = index === cursor ? ">" : " ";
+    const key = `${index + 1}.`;
+    const head = cmd ? `${marker} ${key} ${s.label} (${cmd})` : `${marker} ${key} ${s.label}`;
+    const line = s.hint ? `${head} \u2014 ${s.hint}` : head;
+    return /* @__PURE__ */ jsx(Text, { color: index === cursor ? theme.accent : theme.muted, children: fitText(line, innerWidth) }, s.id);
+  }) });
+}
+
+export {
+  TaskSuggestionBar
+};

package/dist/chunk-CRSLDQOA.js

@@ -0,0 +1,146 @@
+// src/verification-level.ts
+var LEVEL_ORDER = {
+  mock: 0,
+  source: 1,
+  local: 2,
+  build: 3,
+  "real-smoke": 4
+};
+var LEVEL_MATURITY_THRESHOLD = "real-smoke";
+var LEVEL_PASS_THRESHOLD = "build";
+function classifyVerificationLevel(input, verificationRoute) {
+  const level = inferLevel(input);
+  const levelOrder = LEVEL_ORDER[level];
+  const canClaimMature = levelOrder >= LEVEL_ORDER[LEVEL_MATURITY_THRESHOLD];
+  let canClaimPass = levelOrder >= LEVEL_ORDER[LEVEL_PASS_THRESHOLD];
+  const upgradeBlocked = hasUpgradeBlocker(input);
+  if (verificationRoute?.conservativeNoPass) {
+    canClaimPass = false;
+  }
+  return {
+    level,
+    isRealSmoke: level === "real-smoke",
+    canClaimMature: canClaimMature && !upgradeBlocked,
+    canClaimPass: canClaimPass && !upgradeBlocked,
+    upgradeBlocked,
+    blockReason: upgradeBlocked ? getBlockReason(input) : void 0,
+    requiredForMature: getRequiredForMature(level, input)
+  };
+}
+function isNonUpgradeableStatus(status) {
+  const lower = status.toLowerCase();
+  return lower.includes("partial") || lower.includes("simulated") || lower.includes("fallback") || lower.includes("mocked") || lower.includes("source-only") || lower.includes("node_fallback") || lower === "skipped" || lower === "stale";
+}
+function detectVerificationInflation(claimedStatus, actualLevel) {
+  const claimedLower = claimedStatus.toLowerCase();
+  const isMatureClaim = claimedLower.includes("mature") || claimedLower.includes("ready") || claimedLower.includes("production");
+  const isPassClaim = claimedLower === "pass" || claimedLower.includes("pass");
+  if (isMatureClaim && LEVEL_ORDER[actualLevel] < LEVEL_ORDER[LEVEL_MATURITY_THRESHOLD]) {
+    return `Verification inflation: claimed "${claimedStatus}" but actual level is "${actualLevel}". Real smoke required for mature/ready claims.`;
+  }
+  if (isPassClaim && LEVEL_ORDER[actualLevel] < LEVEL_ORDER[LEVEL_PASS_THRESHOLD]) {
+    return `Verification inflation: claimed "${claimedStatus}" but actual level is "${actualLevel}". At least build-level verification required for PASS.`;
+  }
+  return void 0;
+}
+function classifyRunnerVerificationLevel(adapter, status, fallbackReason) {
+  if (adapter === "node" || fallbackReason) {
+    return classifyVerificationLevel({
+      fallbackUsed: true,
+      localTestRunner: true,
+      runnerAdapter: adapter,
+      runnerStatus: status
+    });
+  }
+  if (status === "completed") {
+    return classifyVerificationLevel({
+      realProcessObserved: true,
+      runnerAdapter: adapter,
+      runnerStatus: status
+    });
+  }
+  return classifyVerificationLevel({
+    localTestRunner: true,
+    simulatedOrPartial: status !== "running",
+    runnerAdapter: adapter,
+    runnerStatus: status
+  });
+}
+function classifyProviderVerificationLevel(input) {
+  return classifyVerificationLevel({
+    realProviderHit: input.realEndpointHit && !input.fallbackUsed && !input.mockUsed,
+    mockUsed: input.mockUsed,
+    fallbackUsed: input.fallbackUsed || input.cooldownActive,
+    simulatedOrPartial: input.cooldownActive
+  });
+}
+function formatVerificationLevel(classification) {
+  const parts = [`level=${classification.level}`];
+  if (classification.upgradeBlocked) {
+    parts.push(`blocked=${classification.blockReason ?? "upgrade-blocked"}`);
+  }
+  if (!classification.canClaimPass) {
+    parts.push("pass=not-claimable");
+  }
+  if (!classification.canClaimMature) {
+    parts.push(`mature-requires=${classification.requiredForMature}`);
+  }
+  return parts.join("; ");
+}
+function compareVerificationLevels(a, b) {
+  return LEVEL_ORDER[a] - LEVEL_ORDER[b];
+}
+function inferLevel(input) {
+  if (input.mockUsed || input.fallbackUsed || input.simulatedOrPartial) {
+    if (input.localTestRunner && input.mockUsed && !input.fallbackUsed && !input.simulatedOrPartial) {
+      return "source";
+    }
+    return "mock";
+  }
+  if (input.realProcessObserved || input.realProviderHit || input.realTuiRendered) {
+    return "real-smoke";
+  }
+  if (input.buildPassed) {
+    return "build";
+  }
+  if (input.localTestRunner) {
+    return "local";
+  }
+  if (input.sourceOnlyAnalysis) {
+    return "source";
+  }
+  return "source";
+}
+function hasUpgradeBlocker(input) {
+  return Boolean(input.fallbackUsed || input.simulatedOrPartial || input.mockUsed);
+}
+function getBlockReason(input) {
+  if (input.fallbackUsed) return "fallback-path-used";
+  if (input.simulatedOrPartial) return "simulated-or-partial";
+  if (input.mockUsed) return "mock-used";
+  return "unknown-blocker";
+}
+function getRequiredForMature(currentLevel, input) {
+  if (currentLevel === "real-smoke") return "already-mature";
+  const needs = [];
+  if (!input.realProcessObserved && !input.realProviderHit && !input.realTuiRendered) {
+    needs.push("real-smoke-observation");
+  }
+  if (input.fallbackUsed) {
+    needs.push("main-path-execution");
+  }
+  if (input.mockUsed) {
+    needs.push("real-dependency-verification");
+  }
+  return needs.length > 0 ? needs.join("+") : "real-smoke-required";
+}
+
+export {
+  classifyVerificationLevel,
+  isNonUpgradeableStatus,
+  detectVerificationInflation,
+  classifyRunnerVerificationLevel,
+  classifyProviderVerificationLevel,
+  formatVerificationLevel,
+  compareVerificationLevels
+};