very-happy-cli 0.2.181 → 0.2.183

package/dist/{deterministicJson-BS7D7URE.cjs → deterministicJson-BBRUcB8i.cjs}

@@ -1,9 +1,9 @@
 'use strict';
 
-var logger = require('./logger-DgBwUSgS.cjs');
+var logger = require('./logger-Cgwz30rK.cjs');
 var prompt = require('./prompt-Bof2aQkI.cjs');
-var client = require('./client-DWs6k041.cjs');
-var reportProgressTool = require('./reportProgressTool-th4trcET.cjs');
+var client = require('./client-DcKJ0ul_.cjs');
+var reportProgressTool = require('./reportProgressTool-Be-8ADI4.cjs');
 var node_fs = require('node:fs');
 var os = require('node:os');
 var path = require('node:path');
@@ -11,22 +11,24 @@ var z = require('zod');
 var pi = require('./pi-DlsrPCTa.cjs');
 var promises = require('node:fs/promises');
 var node_crypto = require('node:crypto');
-var client$1 = require('./client-CUO3ItoB.cjs');
-var context = require('./context-D1lgQTJC.cjs');
-var sessionOps = require('./sessionOps-DVA-00nR.cjs');
-var resources = require('./resources-BPyN59Iv.cjs');
-var tools = require('./tools-DiCXnAC5.cjs');
-var peerTools = require('./peerTools-CP-x-Peu.cjs');
+var client$1 = require('./client--vZueZYF.cjs');
+var context = require('./context-DNKNF8Yh.cjs');
+var sessionOps = require('./sessionOps-BWlDlFYP.cjs');
+var resources = require('./resources-CqwHPhdK.cjs');
+var tools = require('./tools-C8rpwyIl.cjs');
+var peerTools = require('./peerTools-Dxe7iCi_.cjs');
 var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
 var node_http = require('node:http');
 var streamableHttp_js = require('@modelcontextprotocol/sdk/server/streamableHttp.js');
 var limits = require('./limits-C-a7gr04.cjs');
-var downloadTarget = require('./downloadTarget-LyOiucn_.cjs');
+var downloadTarget = require('./downloadTarget-CmC11Y7E.cjs');
 var agentGuidance = require('./agentGuidance-BtBx2xxE.cjs');
 var webPanels = require('./webPanels-FCgFKvVe.cjs');
-var persistence = require('./persistence-BY-D00wT.cjs');
-var pushNotifications = require('./pushNotifications-BXoOSq_G.cjs');
+var persistence = require('./persistence-DZRMUZZS.cjs');
+var pushNotifications = require('./pushNotifications-CgIrYml3.cjs');
 var previewPath = require('./previewPath-B0rBdhy1.cjs');
+var index = require('./index-Fq-jxjsB.cjs');
+var configuration = require('./configuration-K3I6yOjZ.cjs');
 var require$$3 = require('crypto');
 
 function createProjectInjector(deps) {
@@ -303,10 +305,6 @@ function createRequestHuman(deps) {
     const reason = rawReason.replace(/\s+/g, " ").trim().slice(0, REQUEST_HUMAN_REASON_MAX);
     if (!reason) return { notified: false, error: "reason must be a non-empty string" };
     await deps.reportBlocked(reason);
-    const at = now();
-    if (last && last.reason === reason && at - last.at < REQUEST_HUMAN_DEDUPE_MS) {
-      return { notified: true, deduped: true };
-    }
     let url = `/session/${encodeURIComponent(deps.sessionId)}`;
     let unknownPanel;
     if (panel) {
@@ -315,18 +313,534 @@ function createRequestHuman(deps) {
       if (machineId && panels.some((p) => p.id === panel)) url = webPanels.webPanelPath(machineId, panel);
       else unknownPanel = panel;
     }
+    if (deps.postBlocked && await deps.postBlocked(reason, unknownPanel ? void 0 : panel).catch(() => false)) {
+      return { notified: true, board: true, ...unknownPanel ? { unknownPanel } : {} };
+    }
+    const at = now();
+    if (last && last.reason === reason && at - last.at < REQUEST_HUMAN_DEDUPE_MS) {
+      return { notified: true, deduped: true };
+    }
     const sent = await deps.sendAttention({ sessionId: deps.sessionId, reason, url });
     if (sent.sent) last = { reason, at };
     return { notified: sent.sent, url, ...unknownPanel ? { unknownPanel } : {}, ...sent.error ? { error: sent.error } : {} };
   };
 }
 function requestHumanResultText(r) {
+  if (r.board) {
+    const panelNote2 = r.unknownPanel ? ` (panel "${r.unknownPanel}" is not declared on this machine, so it is not linked)` : "";
+    return `Posted to the user's briefing board as blocked; the server notifies them once (asking again with the same reason only refreshes it)${panelNote2}. This does not mean they have seen it. Poll your own completion condition (URL changed, element gone) instead of waiting for a reply.`;
+  }
   if (r.deduped) return "Already asked for this in the last minute; the board still shows it. Keep polling your completion condition.";
   if (!r.notified) return `Could not notify the user: ${r.error ?? "unknown error"}. The task board is marked blocked.`;
   const panelNote = r.unknownPanel ? ` (panel "${r.unknownPanel}" is not declared on this machine, so the notification opens the session instead)` : "";
   return `Notified the user${panelNote}. This does not mean they have seen it. Poll your own completion condition (URL changed, element gone) instead of waiting for a reply.`;
 }
 
+const UNSUPPORTED_BACKOFF_MS = 10 * 6e4;
+class AttentionUnsupportedError extends Error {
+  constructor() {
+    super("This Very Happy server has no briefing board");
+  }
+}
+class AttentionRequestError extends Error {
+  constructor(status, code) {
+    super(code ? `Briefing board request failed: ${code}` : `Briefing board request failed (HTTP ${status})`);
+    this.status = status;
+    this.code = code;
+  }
+}
+function isItemErrorCode(code) {
+  return typeof code === "string" && code.startsWith("attention_") || code === "session_not_found";
+}
+function createAttentionClient(deps = {}) {
+  const now = deps.now ?? Date.now;
+  const doFetch = deps.fetch ?? fetch;
+  const token = deps.token ?? (async () => (await persistence.readCredentialsForConfiguredRelay())?.token ?? null);
+  let disabledUntil = 0;
+  async function request(path, method, body, timeoutMs = 1e4) {
+    if (now() < disabledUntil) throw new AttentionUnsupportedError();
+    const bearer = await token();
+    if (!bearer) throw new AttentionRequestError(401, "not_signed_in");
+    const response = await doFetch(`${deps.serverUrl ?? configuration.configuration.serverUrl}${path}`, {
+      method,
+      redirect: "error",
+      headers: { authorization: `Bearer ${bearer}`, ...body === void 0 ? {} : { "content-type": "application/json" } },
+      body: body === void 0 ? void 0 : JSON.stringify(body),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    let json = null;
+    try {
+      json = await response.json();
+    } catch {
+    }
+    if (response.status === 404 && (json?.error === index.ATTENTION_DISABLED_ERROR || !isItemErrorCode(json?.error))) {
+      disabledUntil = now() + UNSUPPORTED_BACKOFF_MS;
+      throw new AttentionUnsupportedError();
+    }
+    if (!response.ok) throw new AttentionRequestError(response.status, typeof json?.error === "string" ? json.error : null);
+    return json;
+  }
+  const enc = encodeURIComponent;
+  return {
+    isDisabled: () => now() < disabledUntil,
+    /** True when this server serves the board for this account (feature flag on). Network errors throw. */
+    async probe(sessionId, timeoutMs = 5e3) {
+      try {
+        await request(`/v1/attention-items?sessionId=${enc(sessionId)}&limit=1`, "GET", void 0, timeoutMs);
+        return true;
+      } catch (error) {
+        if (error instanceof AttentionUnsupportedError) return false;
+        throw error;
+      }
+    },
+    post: (input) => request("/v1/attention-items", "POST", input),
+    patch: (id, patch) => request(`/v1/attention-items/${enc(id)}`, "PATCH", patch),
+    resolve: (id, input) => request(`/v1/attention-items/${enc(id)}/resolve`, "POST", input),
+    list: (query, timeoutMs) => {
+      const params = new URLSearchParams();
+      for (const [key, value] of Object.entries(query)) if (value !== void 0) params.set(key, String(value));
+      return request(`/v1/attention-items?${params.toString()}`, "GET", void 0, timeoutMs);
+    }
+  };
+}
+let shared = null;
+function sharedAttentionClient() {
+  return shared ??= createAttentionClient();
+}
+
+const TRIGGERS = [
+  /需要你(?:来)?(?:决定|拍板|确认|选择|定夺|批准|授权|选)/,
+  /请你?(?:来)?(?:拍板|决定|定夺|确认一下|选择|选一个|选一下)/,
+  /(?:等你|由你|你来)(?:拍板|决定|定夺|确认|选)/,
+  /需要\s*owner\s*(?:决定|拍板|确认)/i,
+  /\b(?:need|needs|waiting for|awaiting)\s+(?:your|the owner'?s?)\s+(?:decision|call|approval|sign-?off|go-?ahead)\b/i,
+  /\b(?:i|we)\s+need\s+you\s+to\s+(?:decide|choose|pick|confirm|approve)\b/i,
+  /\bplease\s+(?:decide|choose|pick one|confirm which|approve)\b/i,
+  /<options>/i
+];
+const OPTION_LINE = /^\s*(?:[-*+]\s+)?(?:\*\*)?(?:选项|option\s*)?([A-Da-d]|[1-4])(?:\*\*)?\s*[.)、:：）]\s*(?:\*\*)?\s*(\S.*?)\s*$/i;
+const TAGGED_OPTION = /<option(?:\s+id="([^"]{1,16})")?\s*>([\s\S]*?)<\/option>/gi;
+const RECOMMENDED = /推荐|建议选|\brecommend(?:ed)?\b|\(rec\)/i;
+function stripCode(text) {
+  return text.replace(/```[\s\S]*?(?:```|$)/g, "\n").replace(/`[^`\n]*`/g, " ");
+}
+function clean(text, max) {
+  const flat = text.replace(/\*\*|__|^#+\s*/g, "").replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+}
+function triggerSentence(text, match) {
+  const start = Math.max(text.lastIndexOf("\n", match.index), ...["\u3002", "\uFF01", "\uFF1F", ". ", "! ", "? "].map((p) => {
+    const at = text.lastIndexOf(p, match.index);
+    return at < 0 ? -1 : at + p.length - 1;
+  })) + 1;
+  const rest = text.slice(match.index);
+  const endRel = rest.search(/[。！？\n]|[.!?](?:\s|$)/);
+  const end = endRel < 0 ? text.length : match.index + endRel + 1;
+  return text.slice(start, end);
+}
+function optionLabel(raw) {
+  return clean(raw.replace(/<[^>]+>/g, ""), index.ATTENTION_LIMITS.optionLabelChars);
+}
+function parseOptions(text) {
+  const tagged = [...text.matchAll(TAGGED_OPTION)].slice(0, index.ATTENTION_LIMITS.options.max);
+  if (tagged.length >= index.ATTENTION_LIMITS.options.min) {
+    return tagged.map((m, i) => ({
+      id: (m[1] ?? String.fromCharCode(65 + i)).slice(0, index.ATTENTION_LIMITS.optionIdChars),
+      label: optionLabel(m[2]) || `Option ${i + 1}`,
+      ...RECOMMENDED.test(m[2]) ? { recommended: true } : {}
+    }));
+  }
+  const groups = [];
+  let current = null;
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    const m = OPTION_LINE.exec(line);
+    if (!m) {
+      current = null;
+      continue;
+    }
+    const id = m[1].toUpperCase();
+    const letter = /[A-D]/.test(id);
+    if (!current || current.letter !== letter || current.lines.some((l) => l.id === id)) {
+      current = { letter, lines: [] };
+      groups.push(current);
+    }
+    current.lines.push({ id, label: optionLabel(m[2]), recommended: RECOMMENDED.test(m[2]) });
+  }
+  const usable = groups.filter((g) => g.lines.length >= index.ATTENTION_LIMITS.options.min && g.lines.every((l) => l.label));
+  const pick = usable.find((g) => g.letter) ?? usable[0];
+  if (!pick) return [];
+  return pick.lines.slice(0, index.ATTENTION_LIMITS.options.max).map((l) => ({ id: l.id, label: l.label, ...l.recommended ? { recommended: true } : {} }));
+}
+function defaultOptions(cjk) {
+  return cjk ? [{ id: "yes", label: "\u540C\u610F" }, { id: "other", label: "\u53E6\u6709\u5B89\u6392\uFF08\u56DE\u590D\u8BF4\u660E\uFF09" }] : [{ id: "yes", label: "Approve" }, { id: "other", label: "Something else (reply)" }];
+}
+function inferOwnerDecision(text) {
+  const prose = stripCode(text);
+  let match = null;
+  for (const trigger of TRIGGERS) {
+    match = trigger.exec(prose);
+    if (match) break;
+  }
+  if (!match) return null;
+  const title = clean(triggerSentence(prose, match).replace(/<\/?options>/gi, ""), index.ATTENTION_LIMITS.titleChars);
+  if (!title) return null;
+  const parsed = parseOptions(text);
+  const options = parsed.length ? parsed : defaultOptions(/[㐀-鿿]/.test(title));
+  const digest = node_crypto.createHash("sha256").update(`${title}
+${options.map((o) => `${o.id}:${o.label}`).join("\n")}`).digest("hex").slice(0, 16);
+  const encoder = new TextEncoder();
+  let bodyMd = text.trim();
+  while (encoder.encode(bodyMd).length > index.ATTENTION_LIMITS.bodyBytes / 2) bodyMd = `${bodyMd.slice(0, Math.floor(bodyMd.length * 0.8))}\u2026`;
+  return { title, options, key: `inferred-${digest}`, bodyMd };
+}
+
+const OWNER_BOARD_DIGEST_TIMEOUT_MS = 1500;
+const QUESTION_TITLE_CHARS = 60;
+const DIGEST_TITLE_CHARS = 40;
+const DIGEST_MAX_CHARS = 480;
+const LEAD_RECHECK_MS = 6e4;
+const OWNER_SENT_FROM = ["web", "mobile", "ios", "android"];
+const AUTOMATED_LOCAL_ID_PREFIXES = ["automation-", "teams-", "remote-send-", "session-message-", "edit-conflict-"];
+function isOwnerMessage(input) {
+  const localId = input.localId ?? "";
+  if (index.isAttentionBoardLocalId(localId)) return false;
+  if (AUTOMATED_LOCAL_ID_PREFIXES.some((prefix) => localId.startsWith(prefix))) return false;
+  return typeof input.sentFrom === "string" && OWNER_SENT_FROM.includes(input.sentFrom);
+}
+function clip(text, max) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+}
+function ownerQuestionTitle(text) {
+  const trimmed = text.trim();
+  if (!trimmed || trimmed.startsWith("/")) return null;
+  const first = trimmed.split("\n").find((line) => line.trim()) ?? "";
+  return clip(first, QUESTION_TITLE_CHARS) || null;
+}
+function minutesAgo(ms, now) {
+  const m = Math.max(0, Math.round((now - ms) / 6e4));
+  return m < 60 ? `${m}m` : `${Math.round(m / 60)}h`;
+}
+function formatBoardDigest(items, now, opts) {
+  if (items.length === 0) return null;
+  const parts = [];
+  let used = 0;
+  let shown = 0;
+  for (const item of items) {
+    const handle = item.key && !item.key.startsWith("req:") ? `key=${item.key}` : `id=${item.id}`;
+    const part = `${item.source === "owner" ? "owner " : ""}${item.kind} \u300C${clip(item.title, DIGEST_TITLE_CHARS)}\u300D ${handle} ${minutesAgo(item.createdAt, now)}`;
+    if (shown > 0 && used + part.length > DIGEST_MAX_CHARS) break;
+    parts.push(part);
+    used += part.length + 2;
+    shown++;
+  }
+  const more = items.length - shown;
+  const line1 = `[Briefing board] ${items.length} open: ${parts.join("; ")}${more > 0 ? `; +${more} more` : ""}`;
+  const line2 = opts.tools ? "[Briefing board] Answer owner items in this turn or settle them with owner_board_update / owner_board_resolve (owner_board_list shows ids); do not repeat open decisions in chat." : null;
+  return line2 ? `${line1}
+${line2}` : line1;
+}
+function parseSince(since) {
+  if (since === void 0) return void 0;
+  if (/^\d+$/.test(since)) return Number(since);
+  const parsed = Date.parse(since);
+  if (Number.isNaN(parsed)) throw new Error("since must be ISO-8601 or epoch milliseconds");
+  return parsed;
+}
+async function resolveTeamLead(sessionId) {
+  try {
+    const scope = await context.readTeamScope(context.teamScopePath(sessionId));
+    if (!scope) return false;
+    const inspected = await client$1.teamRequest(`/v1/teams/${encodeURIComponent(scope.teamId)}/agent`, "GET", scope.scopeToken, true);
+    const bots = Array.isArray(inspected?.team?.bots) ? inspected.team.bots : [];
+    return bots.some((bot) => bot.id === scope.botId && bot.root === true);
+  } catch {
+    return false;
+  }
+}
+function createLeadBoard(deps) {
+  const now = deps.now ?? Date.now;
+  const log = deps.log ?? (() => {
+  });
+  let supported = false;
+  let lead = false;
+  let leadCheckedAt = 0;
+  let toolsFrozen = null;
+  let initPromise = null;
+  let initDone = false;
+  let lastLocalId = null;
+  let pending = [];
+  let turn = null;
+  let work = Promise.resolve();
+  const queue = (task) => {
+    work = work.then(task).catch((error) => log(`[ownerBoard] ${error instanceof Error ? error.message : String(error)}`));
+    return work;
+  };
+  async function refreshLead() {
+    if (lead || now() - leadCheckedAt < LEAD_RECHECK_MS) return lead;
+    leadCheckedAt = now();
+    lead = await deps.isLead().catch(() => false);
+    return lead;
+  }
+  function init() {
+    return initPromise ??= (async () => {
+      try {
+        supported = await deps.client.probe(deps.sessionId());
+      } catch (error) {
+        log(`[ownerBoard] probe failed: ${error instanceof Error ? error.message : String(error)}`);
+        supported = false;
+      }
+      if (supported) {
+        deps.onSupported?.();
+        await refreshLead();
+      }
+      initDone = true;
+    })();
+  }
+  async function active() {
+    await init();
+    return supported && !deps.client.isDisabled() && await refreshLead();
+  }
+  function thisTurnAnchor() {
+    const localId = turn?.promptLocalId ?? lastLocalId;
+    if (!localId) return void 0;
+    const text = turn?.texts.at(-1);
+    return { localId, ...text ? { snippet: clip(text, index.ATTENTION_LIMITS.snippetChars) } : {} };
+  }
+  const noteBoardTool = (name) => {
+    turn?.boardTools.add(name);
+  };
+  async function settleQuestions(questions, reply) {
+    for (const question of questions) {
+      const id = await question.itemId;
+      if (!id) continue;
+      const anchor = { localId: question.localId, snippet: clip(reply, index.ATTENTION_LIMITS.snippetChars) };
+      const { item } = await deps.client.patch(id, { firstReply: anchor, requestId: `first-reply-${question.localId}`.slice(0, 128) });
+      if (item.state === "open") {
+        await deps.client.resolve(id, { outcome: "answered", by: "auto-first-reply", requestId: `auto-answered-${question.localId}`.slice(0, 128) });
+      }
+    }
+  }
+  async function draftDecision(text, anchor) {
+    if (!await deps.autoDetect().catch(() => true)) return;
+    const draft = inferOwnerDecision(text);
+    if (!draft) return;
+    await deps.client.post({
+      sessionId: deps.sessionId(),
+      source: "lead",
+      kind: "decision",
+      inferred: true,
+      title: draft.title,
+      bodyMd: draft.bodyMd,
+      options: draft.options,
+      key: draft.key,
+      ...anchor ? { anchor } : {},
+      requestId: node_crypto.randomUUID()
+    });
+  }
+  return {
+    init,
+    /** Waits (bounded) for the first probe so the first `tools/list` sees the final tool set. */
+    async ready(timeoutMs) {
+      await Promise.race([init(), new Promise((resolve) => setTimeout(resolve, timeoutMs).unref?.())]);
+    },
+    /** Server serves the board (any session: request_human items, `owner-board-v1`). */
+    supported: () => supported && !deps.client.isDisabled(),
+    /**
+     * `owner_board_*` exposure, decided once per process: the tool list must
+     * not change under a running agent. A session adopted into a team later
+     * gets the tools on its next relaunch; the fallbacks start at once.
+     */
+    toolsExposed() {
+      if (toolsFrozen === null && initDone) toolsFrozen = supported && lead;
+      return toolsFrozen ?? false;
+    },
+    // ─── tools ──────────────────────────────────────────────────────────
+    async post(input) {
+      noteBoardTool("owner_board_post");
+      const anchor = input.anchor === void 0 || input.anchor === "this_turn" ? thisTurnAnchor() : { localId: input.anchor.localId };
+      const { item, created } = await deps.client.post(index.ownerBoardPostToRest(deps.sessionId(), input, anchor));
+      return { id: item.id, created };
+    },
+    async update(input) {
+      noteBoardTool("owner_board_update");
+      return deps.client.patch(input.id, {
+        ...input.title !== void 0 ? { title: input.title } : {},
+        ...input.body_md !== void 0 ? { bodyMd: input.body_md } : {},
+        ...input.append_md !== void 0 ? { appendMd: input.append_md } : {},
+        ...input.options !== void 0 ? { options: input.options } : {},
+        ...input.links !== void 0 ? { links: input.links } : {},
+        ...input.state !== void 0 ? { state: input.state } : {},
+        requestId: input.request_id
+      });
+    },
+    async resolve(input) {
+      noteBoardTool("owner_board_resolve");
+      return deps.client.resolve(input.id, { outcome: input.outcome, ...input.note !== void 0 ? { note: input.note } : {}, by: "lead", requestId: input.request_id });
+    },
+    async list(input) {
+      const since = parseSince(input.since);
+      return deps.client.list({ sessionId: deps.sessionId(), state: input.state === "all" ? "all" : "open", limit: 50, ...since !== void 0 ? { since } : {} });
+    },
+    /**
+     * `request_human` as a `blocked` item (server dedupes by key and pushes
+     * once). False when this server has no board: the caller keeps the old
+     * metadata + push path.
+     */
+    async postBlocked(reason, panel) {
+      noteBoardTool("request_human");
+      await init();
+      if (!supported || deps.client.isDisabled()) return false;
+      try {
+        await deps.client.post({
+          sessionId: deps.sessionId(),
+          source: "agent",
+          kind: "blocked",
+          title: clip(reason, index.ATTENTION_LIMITS.titleChars),
+          ...reason.length > index.ATTENTION_LIMITS.titleChars ? { bodyMd: reason } : {},
+          key: `request-human-${node_crypto.createHash("sha256").update(reason).digest("hex").slice(0, 16)}`,
+          ...panel ? { links: [{ type: "panel", ref: panel }] } : {},
+          ...thisTurnAnchor() ? { anchor: thisTurnAnchor() } : {},
+          requestId: node_crypto.randomUUID()
+        });
+        return true;
+      } catch (error) {
+        if (!(error instanceof AttentionUnsupportedError)) log(`[ownerBoard] request_human item failed: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+      }
+    },
+    // ─── message taps ───────────────────────────────────────────────────
+    /** Every routed user message (any runner). Owner messages in a lead session become `question` items. */
+    onUserMessage(message) {
+      if (message.localId) lastLocalId = message.localId;
+      if (!message.localId || !isOwnerMessage(message)) return;
+      const title = ownerQuestionTitle(message.text ?? "");
+      if (!title) return;
+      const localId = message.localId;
+      const itemId = (async () => {
+        if (!await active()) return null;
+        const { item } = await deps.client.post({
+          sessionId: deps.sessionId(),
+          source: "owner",
+          kind: "question",
+          title,
+          anchor: { localId, snippet: clip(message.text ?? "", index.ATTENTION_LIMITS.snippetChars) },
+          // No key: the server keys it by request id, so a replay after a restart is a no-op.
+          requestId: `owner-q-${localId}`.slice(0, 128)
+        });
+        return item.id;
+      })().catch((error) => {
+        log(`[ownerBoard] owner question not posted: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+      });
+      const question = { localId, itemId };
+      if (message.delivery === "steer" && turn) turn.questions.push(question);
+      else pending.push(question);
+    },
+    /**
+     * The agent takes queued input (Claude remote launcher, right before the
+     * prompt goes to the SDK). `sourceIds` = the batch's message localIds when
+     * known: only those questions belong to this turn. When none match (an
+     * id scheme we do not recognise) every waiting question does.
+     */
+    onTurnStart(sourceIds) {
+      const ids = new Set(sourceIds ?? []);
+      const mine = pending.filter((q) => ids.has(q.localId));
+      const questions = ids.size && mine.length ? mine : pending;
+      pending = pending.filter((q) => !questions.includes(q));
+      turn = { promptLocalId: sourceIds?.at(-1) ?? lastLocalId, questions, texts: [], boardTools: /* @__PURE__ */ new Set() };
+    },
+    onAssistantText(text) {
+      if (!turn || !text.trim() || turn.texts.at(-1) === text) return;
+      turn.texts.push(text);
+    },
+    onTurnEnd() {
+      const ended = turn;
+      turn = null;
+      if (!ended) return work;
+      const anchor = ended.promptLocalId ? { localId: ended.promptLocalId } : void 0;
+      return queue(async () => {
+        const reply = ended.texts.join("\n\n").trim();
+        if (!reply || !await active()) return;
+        if (ended.questions.length) await settleQuestions(ended.questions, ended.texts[0]);
+        if (!ended.boardTools.has("owner_board_post") && !ended.boardTools.has("request_human")) {
+          await draftDecision(reply, anchor ? { ...anchor, snippet: clip(ended.texts.at(-1) ?? reply, index.ATTENTION_LIMITS.snippetChars) } : void 0);
+        }
+      });
+    },
+    /** Prefix the turn's prompt with the open-items digest (lead sessions only; unchanged on any failure). */
+    async decorate(message) {
+      if (typeof message !== "string") return message;
+      try {
+        const result = await Promise.race([
+          (async () => {
+            if (!await active()) return null;
+            const fresh = new Set(turn?.questions.map((q) => q.localId) ?? []);
+            const { items } = await deps.client.list({ sessionId: deps.sessionId(), state: "open", limit: 20 }, OWNER_BOARD_DIGEST_TIMEOUT_MS);
+            return formatBoardDigest(items.filter((item) => !(item.anchor?.localId && fresh.has(item.anchor.localId) && item.source === "owner")), now(), { tools: toolsFrozen === true });
+          })(),
+          new Promise((resolve) => setTimeout(() => resolve(null), OWNER_BOARD_DIGEST_TIMEOUT_MS).unref?.())
+        ]);
+        return result ? `${result}
+${message}` : message;
+      } catch (error) {
+        log(`[ownerBoard] digest skipped: ${error instanceof Error ? error.message : String(error)}`);
+        return message;
+      }
+    },
+    /** Settles once queued turn-end follow-ups are done (tests, shutdown). */
+    idle: () => work
+  };
+}
+const boards = /* @__PURE__ */ new WeakMap();
+function attachLeadBoard(client, board) {
+  boards.set(client, board);
+}
+function leadBoardFor(client) {
+  return boards.get(client);
+}
+
+const OWNER_BOARD_TOOL_NAMES = ["owner_board_post", "owner_board_update", "owner_board_resolve", "owner_board_list"];
+const POST_DESCRIPTION = "Post to the owner's briefing board (\u6C47\u62A5\u677F / Briefing), the one place the user checks for what needs them. kind: decision (they must choose; 2-4 options, mark the recommended one), todo (something only they can do offline: log in, authorize, look at a device), report (a milestone: accepted, merged, released, incident conclusion), answer (reply_to = the owner question item id). Use a stable key per topic: posting the same key again updates that item instead of adding one. anchor defaults to this turn's reply. Do not also paste open decisions into chat or member replies.";
+const UPDATE_DESCRIPTION = `Edit one of this session's briefing board items, or set state in_progress ("on it, the result will come to the board") / open. Use it to refresh a reminder instead of repeating it in chat; an owner question can be reclassified only by the board itself.`;
+const RESOLVE_DESCRIPTION = "Close one of this session's briefing board items: done, answered, dropped or superseded (say why in note).";
+const LIST_DESCRIPTION = "List this session's briefing board items with the owner's choice and note. state: open (default) or all; since: ISO-8601 or epoch ms.";
+function errorText(error) {
+  if (error instanceof AttentionUnsupportedError) return "The briefing board is not available on this server right now.";
+  if (error instanceof AttentionRequestError) return error.message;
+  return error instanceof Error ? error.message : "Briefing board request failed";
+}
+function registerOwnerBoardTools(server, board) {
+  const register = (name, description, schema, execute, readOnly = false) => {
+    server.registerTool(name, {
+      description,
+      inputSchema: schema.shape,
+      annotations: { readOnlyHint: readOnly, idempotentHint: true, openWorldHint: false, destructiveHint: false }
+    }, async (args) => {
+      const parsed = schema.safeParse(args);
+      if (!parsed.success) {
+        return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues.map((i) => `${i.path.join(".") || "input"}: ${i.message}`).join("; ")}` }], isError: true };
+      }
+      try {
+        return { content: [{ type: "text", text: JSON.stringify(await execute(parsed.data)) }], isError: false };
+      } catch (error) {
+        return { content: [{ type: "text", text: errorText(error) }], isError: true };
+      }
+    });
+  };
+  register("owner_board_post", POST_DESCRIPTION, index.OwnerBoardPostInputSchema, (args) => board.post(args));
+  register("owner_board_update", UPDATE_DESCRIPTION, index.OwnerBoardUpdateInputSchema, (args) => board.update(args));
+  register("owner_board_resolve", RESOLVE_DESCRIPTION, index.OwnerBoardResolveInputSchema, (args) => board.resolve(args));
+  register("owner_board_list", LIST_DESCRIPTION, index.OwnerBoardListInputSchema, (args) => board.list(args), true);
+}
+
+const OWNER_BOARD_READY_MS = 3e3;
+function assistantTexts(body) {
+  const line = body;
+  if (line?.type !== "assistant" || line.isSidechain || !Array.isArray(line.message?.content)) return [];
+  return line.message.content.filter((block) => block?.type === "text" && typeof block.text === "string" && block.text.trim()).map((block) => block.text);
+}
 function createMcpServer(handlers, options, sessionId, client) {
   const mcp = new mcp_js.McpServer({
     name: "Very Happy Tools",
@@ -458,6 +972,32 @@ function withoutPhase(board) {
 async function startHappyServer(client, options) {
   logger.logger.debug(`[happyMCP] server:start sessionId=${client.sessionId} assistant=${!!options?.assistant}`);
   const selfReportState = options?.selfReportState ?? reportProgressTool.createSelfReportState();
+  const leadBoard = createLeadBoard({
+    sessionId: () => client.sessionId,
+    client: sharedAttentionClient(),
+    isLead: () => resolveTeamLead(client.sessionId),
+    autoDetect: async () => (await persistence.readSettings()).ownerBoardAutoDetect !== false,
+    onSupported: () => client.updateMetadata((metadata) => ({ ...metadata, capabilities: [.../* @__PURE__ */ new Set([...metadata.capabilities ?? [], index.ATTENTION_SESSION_CAPABILITY])] })),
+    log: (message) => logger.logger.debug(message)
+  });
+  attachLeadBoard(client, leadBoard);
+  void leadBoard.init();
+  const onRoutedUserMessage = (event) => {
+    const text = event.message?.content?.text;
+    leadBoard.onUserMessage({ localId: event.localId, text: typeof text === "string" ? text : null, sentFrom: event.message?.meta?.sentFrom, delivery: event.message?.meta?.delivery });
+  };
+  const onClaudeLine = (body) => {
+    for (const text of assistantTexts(body)) leadBoard.onAssistantText(text);
+  };
+  const onTurnEnded = () => {
+    void leadBoard.onTurnEnd();
+  };
+  const tapped = typeof client.on === "function";
+  if (tapped) {
+    client.on("user-message-routed", onRoutedUserMessage);
+    client.on("claude-session-message", onClaudeLine);
+    client.on("turn-ended", onTurnEnded);
+  }
   const handlers = {
     openPreview: async (path, mode, download = false) => {
       const verdict = previewPath.checkPreviewPath(path);
@@ -538,7 +1078,8 @@ async function startHappyServer(client, options) {
       readPanels: async () => (await persistence.readSettings()).webPanels,
       // Same board write (and attention-change throttle bypass) as report_progress.
       reportBlocked: (reason) => handlers.reportProgress(reason, "blocked"),
-      sendAttention: (input) => options?.push ? options.push.sendAttention({ ...input, sessionTitle: pushNotifications.getSessionNotificationBody(client.getMetadata()) }) : Promise.resolve({ sent: false, error: "push is not available in this runner" })
+      sendAttention: (input) => options?.push ? options.push.sendAttention({ ...input, sessionTitle: pushNotifications.getSessionNotificationBody(client.getMetadata()) }) : Promise.resolve({ sent: false, error: "push is not available in this runner" }),
+      postBlocked: (reason, panel) => leadBoard.postBlocked(reason, panel)
     })
   };
   const contextPath = "/runtime-context/" + node_crypto.randomUUID();
@@ -612,7 +1153,9 @@ async function startHappyServer(client, options) {
       }
       return;
     }
+    await leadBoard.ready(OWNER_BOARD_READY_MS);
     const mcp = createMcpServer(handlers, options, client.sessionId, client);
+    if (leadBoard.toolsExposed()) registerOwnerBoardTools(mcp, leadBoard);
     try {
       const transport = new streamableHttp_js.StreamableHTTPServerTransport({
         sessionIdGenerator: void 0
@@ -657,11 +1200,19 @@ async function startHappyServer(client, options) {
       ...reportProgressTool.AUTOMATION_TOOL_NAMES,
       ...peerTools.SESSION_PEER_TOOL_NAMES,
       ...reportProgressTool.PROJECT_TOOL_NAMES,
+      // Auto-allow only; the tools themselves appear for a lead on a board server.
+      ...OWNER_BOARD_TOOL_NAMES,
       ...options?.assistant && !process.env.VH_TEAM_SCOPE_FILE ? downloadTarget.ASSISTANT_TOOL_NAMES : []
     ],
+    leadBoard,
     stop: () => {
       logger.logger.debug(`[happyMCP] server:stop sessionId=${client.sessionId}`);
       if (adoptionEnabled) client.rpcHandlerManager.unregisterHandler("teams-adopt");
+      if (tapped) {
+        client.off("user-message-routed", onRoutedUserMessage);
+        client.off("claude-session-message", onClaudeLine);
+        client.off("turn-ended", onTurnEnded);
+      }
       server.close();
     }
   };
@@ -755,6 +1306,7 @@ function hashObject(obj, options, encoding = "hex") {
 
 exports.createProjectInjector = createProjectInjector;
 exports.hashObject = hashObject;
+exports.leadBoardFor = leadBoardFor;
 exports.readPiModelsJson = readPiModelsJson;
 exports.resolvePiContextUsage = resolvePiContextUsage;
 exports.startHappyServer = startHappyServer;