viveworker 0.4.6 → 0.4.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "viveworker",
-  "version": "0.4.6",
+  "version": "0.4.7",
   "description": "Local mobile companion for Codex Desktop and Claude Desktop — approvals, code review, Moltbook drafts, and A2A (Agent-to-Agent) task relay on your LAN.",
   "author": "Yuta Hoshino <hoshino.lireneo@gmail.com>",
   "license": "MIT",

package/scripts/viveworker-bridge.mjs

@@ -28,7 +28,7 @@ const sessionCookieName = "viveworker_session";
 const deviceCookieName = "viveworker_device";
 const historyKinds = new Set(["completion", "plan_ready", "approval", "plan", "choice", "info"]);
 const timelineMessageKinds = new Set(["user_message", "assistant_commentary", "assistant_final"]);
-const timelineKinds = new Set([...timelineMessageKinds, "approval", "plan", "choice", "completion", "plan_ready", "file_event", "moltbook_reply", "moltbook_draft"]);
+const timelineKinds = new Set([...timelineMessageKinds, "approval", "plan", "choice", "completion", "plan_ready", "file_event", "moltbook_reply", "moltbook_draft", "thread_share"]);
 const SQLITE_COMPLETION_BATCH_SIZE = 200;
 const DEFAULT_DEVICE_TRUST_TTL_MS = 30 * 24 * 60 * 60 * 1000;
 const MAX_PAIRED_DEVICES = 200;
@@ -85,6 +85,8 @@ const runtime = {
   moltbookItemsByToken: new Map(),
   moltbookDraftsByToken: new Map(),
   a2aTasksByToken: new Map(),
+  threadSharesByToken: new Map(),
+  threadRegistry: new Map(),
   planDetailsByToken: new Map(),
   recentHistoryItems: [],
   recentTimelineEntries: [],
@@ -94,6 +96,7 @@ const runtime = {
   stopping: false,
 };
 const state = await loadState(config.stateFile);
+runtime.threadRegistry = await loadThreadRegistry(config.threadRegistryFile);
 await syncClaudeAwayModeSentinel(config, state.claudeAwayMode === true);
 const migratedPairedDevicesStateChanged = migratePairedDevicesState({ config, state });
 const restoredPendingPlanStateChanged = restorePendingPlanRequests({ config, runtime, state });
@@ -6970,6 +6973,20 @@ class NativeIpcClient {
 
     this.runtime.threadStates.set(normalized.conversationId, nextState);
 
+    // Register / update in the persistent thread registry.
+    const regLabel = extractThreadLabelFromState(nextState)
+      || getThreadName(this.runtime.sessionIndex, this.runtime.rolloutThreadLabels, normalized.conversationId, nextState.cwd || "", "");
+    if (registerThread(this.runtime, {
+      id: normalized.conversationId,
+      label: regLabel,
+      tool: "codex",
+      cwd: nextState.cwd || "",
+      lastSeenAtMs: Date.now(),
+      active: true,
+    })) {
+      saveThreadRegistry(this.config.threadRegistryFile, this.runtime.threadRegistry).catch(() => {});
+    }
+
     await this.onThreadStateChanged({
       conversationId: normalized.conversationId,
       previousRequests,
@@ -9067,6 +9084,24 @@ function buildPendingInboxItems(runtime, state, config, locale) {
     });
   }
 
+  for (const share of runtime.threadSharesByToken.values()) {
+    if (share.decision) continue;
+    const title = share.sourceLabel
+      ? `${share.sourceLabel} → ${share.targetLabel || share.targetTool}`
+      : `→ ${share.targetLabel || share.targetTool}`;
+    items.push({
+      kind: "thread_share",
+      token: share.token,
+      threadId: "thread_share",
+      threadLabel: "Thread Share",
+      title,
+      summary: String(share.content || "").slice(0, 160),
+      primaryLabel: t(locale, "server.action.review"),
+      createdAtMs: Number(share.createdAtMs) || now,
+      provider: "viveworker",
+    });
+  }
+
   // Moltbook reply items intentionally do not appear in the unhandled list.
   // Reply drafting is delegated to Codex/Claude Desktop via the
   // `viveworker moltbook` CLI, so they live in the timeline only.
@@ -10611,6 +10646,42 @@ async function buildApiItemDetail({ config, runtime, state, kind, token, locale
     };
   }
 
+  if (kind === "thread_share") {
+    const share = runtime.threadSharesByToken.get(token);
+    const entry = share
+      ? null
+      : runtime.recentTimelineEntries.find((e) => e.kind === "thread_share" && e.token === token);
+    const source = share || entry;
+    if (!source) return null;
+    const content = share ? share.content : entry.messageText || entry.summary || "";
+    const messageHtml = escapeHtml(content)
+      .split("\n")
+      .map((line) => `<p>${line}</p>`)
+      .join("");
+    return {
+      kind: "thread_share",
+      token,
+      threadId: "thread_share",
+      threadLabel: "Thread Share",
+      title: source.title || "Thread Share",
+      summary: source.summary || cleanText(content).slice(0, 160),
+      messageHtml,
+      provider: "viveworker",
+      shareContent: content,
+      shareType: share?.shareType || entry?.shareType || "message",
+      sourceTool: share?.sourceTool || entry?.sourceTool || "",
+      sourceLabel: share?.sourceLabel || entry?.sourceLabel || "",
+      targetTool: share?.targetTool || entry?.targetTool || "",
+      targetLabel: share?.targetLabel || entry?.targetLabel || "",
+      targetConversationId: share?.targetConversationId || entry?.targetConversationId || "",
+      contextFiles: share?.contextFiles || entry?.contextFiles || [],
+      createdAtMs: source.createdAtMs || Date.now(),
+      readOnly: !share || Boolean(share?.decision),
+      actions: [],
+      threadShareEnabled: Boolean(share) && !share.decision,
+    };
+  }
+
   const historyItem = historyItemByToken(runtime, kind, token);
   return historyItem ? buildHistoryDetail(historyItem, locale, runtime) : null;
 }
@@ -11149,6 +11220,318 @@ function createNativeApprovalServer({ config, runtime, state }) {
         });
       }
 
+      // ─── Thread sharing ──────────────────────────────────────────────
+
+      function buildThreadShareContent(shareType, body) {
+        if (shareType === "plan_review") {
+          const sections = [];
+          if (body.context) sections.push(`## Context\n${body.context}`);
+          if (body.plan) sections.push(`## Plan\n${body.plan}`);
+          if (Array.isArray(body.files) && body.files.length) {
+            sections.push(`## Relevant files\n${body.files.map((f) => `- ${f}`).join("\n")}`);
+          }
+          sections.push(`## Instruction\n${body.instruction || "共有されたプランの内容を把握し、実現可能性や改善点を検討してください。"}`);
+          return sections.join("\n\n");
+        }
+        if (shareType === "handoff") {
+          const sections = [];
+          if (body.summary) sections.push(`## Summary\n${body.summary}`);
+          if (Array.isArray(body.completed) && body.completed.length) {
+            sections.push(`## Completed\n${body.completed.map((t) => `- ${t}`).join("\n")}`);
+          }
+          if (Array.isArray(body.remaining) && body.remaining.length) {
+            sections.push(`## Remaining\n${body.remaining.map((t) => `- ${t}`).join("\n")}`);
+          }
+          if (Array.isArray(body.decisions) && body.decisions.length) {
+            sections.push(`## Key decisions\n${body.decisions.map((d) => `- ${d}`).join("\n")}`);
+          }
+          if (Array.isArray(body.modifiedFiles) && body.modifiedFiles.length) {
+            sections.push(`## Modified files\n${body.modifiedFiles.map((f) => `- ${f}`).join("\n")}`);
+          }
+          sections.push(`## Instruction\n${body.instruction || "これまでの作業内容と経緯を把握した上で、次に何をすべきか検討してください。"}`);
+          return sections.join("\n\n");
+        }
+        // Default: message type — use raw content.
+        return cleanText(body?.content || "");
+      }
+
+      // List known threads (active + registry) for the share target picker.
+      if (url.pathname === "/api/threads/list" && req.method === "GET") {
+        const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
+        const hookAuth = config.sessionSecret && hookSecret === config.sessionSecret;
+        if (!hookAuth) { const session = requireApiSession(req, res, config, state); if (!session) return; }
+        const codexConnected = Boolean(runtime.ipcClient?.clientId);
+        const activeIds = new Set();
+        const threads = [];
+        // Active Codex threads (from IPC).
+        for (const [conversationId, threadState] of runtime.threadStates) {
+          activeIds.add(conversationId);
+          const label = getThreadName(
+            runtime.sessionIndex,
+            runtime.rolloutThreadLabels,
+            conversationId,
+            cleanText(threadState?.cwd || ""),
+            ""
+          );
+          threads.push({
+            conversationId,
+            label: label || conversationId.slice(0, 8),
+            tool: "codex",
+            cwd: cleanText(threadState?.cwd || ""),
+            hasOwner: runtime.threadOwnerClientIds.has(conversationId),
+            active: true,
+          });
+        }
+        // Registry entries not already covered by active threads.
+        for (const entry of runtime.threadRegistry.values()) {
+          if (!activeIds.has(entry.id)) {
+            threads.push({
+              conversationId: entry.id,
+              label: entry.label || entry.id.slice(0, 8),
+              tool: entry.tool || "codex",
+              cwd: entry.cwd || "",
+              hasOwner: false,
+              active: false,
+              lastSeenAtMs: entry.lastSeenAtMs || 0,
+            });
+          }
+        }
+        return writeJson(res, 200, { threads, codexConnected });
+      }
+
+      // Submit a thread share request (creates an approval item on the phone).
+      if (url.pathname === "/api/threads/share" && req.method === "POST") {
+        const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
+        const hookAuth = config.sessionSecret && hookSecret === config.sessionSecret;
+        if (!hookAuth) { const session = requireApiSession(req, res, config, state); if (!session) return; }
+        const body = await parseJsonBody(req);
+        const shareType = cleanText(body?.shareType || "message");
+        const sourceTool = cleanText(body?.sourceTool || "");
+        const sourceLabel = cleanText(body?.sourceLabel || "");
+        const targetConversationId = cleanText(body?.targetConversationId || "");
+        let targetTool = cleanText(body?.targetTool || "");
+        let targetCwd = cleanText(body?.targetCwd || "");
+        const contextFiles = Array.isArray(body?.contextFiles)
+          ? body.contextFiles.map((f) => cleanText(String(f))).filter(Boolean)
+          : [];
+
+        // Auto-resolve targetTool and targetCwd from registry if not provided.
+        if (targetConversationId) {
+          const regEntry = runtime.threadRegistry.get(targetConversationId);
+          if (regEntry) {
+            if (!targetTool) targetTool = regEntry.tool || "";
+            if (!targetCwd) targetCwd = regEntry.cwd || "";
+          }
+        }
+
+        // Build content from structured fields depending on shareType.
+        const content = buildThreadShareContent(shareType, body);
+        if (!content && contextFiles.length === 0) {
+          return writeJson(res, 400, { error: "missing-content" });
+        }
+        if (!targetConversationId && !targetTool) {
+          return writeJson(res, 400, { error: "missing-target" });
+        }
+        const shareId = crypto.randomUUID();
+        const token = historyToken(`thread_share:${shareId}`);
+        const targetLabel = targetConversationId
+          ? (getThreadName(runtime.sessionIndex, runtime.rolloutThreadLabels, targetConversationId, runtime.threadStates.get(targetConversationId)?.cwd || "", "") || runtime.threadRegistry.get(targetConversationId)?.label || "")
+          : targetTool;
+        const share = {
+          token,
+          shareId,
+          shareType,
+          content: content || "",
+          contextFiles,
+          sourceTool,
+          sourceLabel,
+          targetConversationId,
+          targetTool: targetTool || "codex",
+          targetCwd,
+          targetLabel,
+          createdAtMs: Date.now(),
+          decision: null,
+          decisionWaiters: [],
+        };
+        runtime.threadSharesByToken.set(token, share);
+        try {
+          const title = sourceLabel
+            ? `${sourceLabel} → ${targetLabel || targetTool}`
+            : `→ ${targetLabel || targetTool}`;
+          recordTimelineEntry({
+            config, runtime, state,
+            entry: {
+              stableId: `thread_share:${shareId}`,
+              token,
+              kind: "thread_share",
+              threadId: "thread_share",
+              threadLabel: "Thread Share",
+              title,
+              summary: String(content).slice(0, 160),
+              messageText: content,
+              createdAtMs: share.createdAtMs,
+              readOnly: false,
+              provider: "viveworker",
+            },
+          });
+          await saveState(config.stateFile, state);
+        } catch (error) {
+          console.error(`[thread-share-timeline] ${error.message}`);
+        }
+        try {
+          await deliverWebPushItem({
+            config, state,
+            kind: "thread_share",
+            token,
+            stableId: `thread_share:${shareId}`,
+            title: `Thread Share: ${sourceLabel || sourceTool || "agent"} → ${targetLabel || targetTool}`,
+            body: String(content).slice(0, 160),
+          });
+        } catch (error) {
+          console.error(`[thread-share-push] ${error.message}`);
+        }
+        return writeJson(res, 200, { ok: true, token, shareId });
+      }
+
+      // Decision endpoint for thread share (approve / deny from phone).
+      const threadShareDecisionMatch = url.pathname.match(/^\/api\/threads\/share\/([^/]+)\/decision$/);
+      if (threadShareDecisionMatch && req.method === "POST") {
+        const session = requireApiSession(req, res, config, state);
+        if (!session) return;
+        const token = cleanText(threadShareDecisionMatch[1]);
+        const share = runtime.threadSharesByToken.get(token);
+        if (!share) {
+          return writeJson(res, 404, { error: "not-found" });
+        }
+        if (share.decision) {
+          return writeJson(res, 200, { ok: true, decision: share.decision });
+        }
+        const body = await parseJsonBody(req);
+        const decision = cleanText(body?.decision || "");
+        const editedContent = typeof body?.editedContent === "string" ? body.editedContent : null;
+        if (decision !== "approve" && decision !== "deny") {
+          return writeJson(res, 400, { error: "invalid-decision" });
+        }
+        share.decision = decision;
+        if (editedContent !== null) {
+          share.content = editedContent;
+        }
+
+        // Deliver the shared content to the target.
+        let deliveryStatus = "delivered";
+        if (decision === "approve") {
+          const prefix = share.sourceLabel ? `[Shared from ${share.sourceLabel}]\n\n` : "[Shared from another thread]\n\n";
+          // Append context file references if present.
+          if (share.contextFiles && share.contextFiles.length > 0) {
+            const fileList = share.contextFiles.map((f) => `- ${f}`).join("\n");
+            share.content = (share.content ? share.content + "\n\n" : "")
+              + `## Context files\n\nRead the following files for full conversation context:\n${fileList}`;
+          }
+          let injectedViaIpc = false;
+
+          // Try Codex IPC injection if targeting a specific thread.
+          if (share.targetConversationId && runtime.ipcClient?.clientId) {
+            const ownerClientId = runtime.threadOwnerClientIds.get(share.targetConversationId) ?? null;
+            const turnStartParams = { input: buildTurnInput(prefix + share.content) };
+            // Try direct first, then fall back to thread-follower.
+            for (const transport of ["direct", "follower"]) {
+              try {
+                if (transport === "direct" && ownerClientId) {
+                  await runtime.ipcClient.startTurnDirect(share.targetConversationId, turnStartParams, ownerClientId);
+                } else {
+                  await runtime.ipcClient.startTurn(share.targetConversationId, turnStartParams, ownerClientId);
+                }
+                injectedViaIpc = true;
+                console.log(`[thread-share] Delivered to Codex thread ${share.targetConversationId} via ${transport}`);
+                break;
+              } catch (error) {
+                console.error(`[thread-share-ipc-${transport}] ${error.message}`);
+              }
+            }
+          }
+
+          // Write to file inbox (always for claude-code targets, fallback for failed Codex delivery).
+          if (!injectedViaIpc) {
+            try {
+              const inboxDir = path.join(os.homedir(), ".viveworker", "thread-inbox");
+              await fs.mkdir(inboxDir, { recursive: true });
+              const inboxFile = path.join(inboxDir, `${share.shareId}.json`);
+              await fs.writeFile(inboxFile, JSON.stringify({
+                shareId: share.shareId,
+                content: share.content,
+                contextFiles: share.contextFiles || [],
+                targetCwd: share.targetCwd || "",
+                sourceTool: share.sourceTool,
+                sourceLabel: share.sourceLabel,
+                targetTool: share.targetTool,
+                createdAtMs: share.createdAtMs,
+                deliveredAtMs: Date.now(),
+              }, null, 2), "utf8");
+              console.log(`[thread-share] Written to inbox: ${inboxFile}`);
+            } catch (error) {
+              console.error(`[thread-share-inbox-write] ${error.message}`);
+            }
+
+            // If the user intended Codex but it wasn't reachable, notify.
+            if (share.targetConversationId && share.targetTool !== "claude-code") {
+              deliveryStatus = "inbox_fallback";
+              try {
+                await deliverWebPushItem({
+                  config, state,
+                  kind: "thread_share",
+                  token: share.token,
+                  stableId: `thread_share_fallback:${share.shareId}`,
+                  title: "Thread Share: target unreachable",
+                  body: `Codex thread "${share.targetLabel || share.targetConversationId.slice(0, 8)}" is not connected. Content saved to inbox.`,
+                });
+              } catch (error) {
+                console.error(`[thread-share-fallback-push] ${error.message}`);
+              }
+            }
+          }
+        }
+
+        // Wake any long-poll waiters.
+        for (const waiter of share.decisionWaiters) {
+          waiter({ decision: share.decision, content: share.content });
+        }
+        share.decisionWaiters = [];
+        return writeJson(res, 200, { ok: true, decision: share.decision });
+      }
+
+      // Long-poll: wait for a thread share decision (used by the CLI or hook).
+      const threadSharePollMatch = url.pathname.match(/^\/api\/threads\/share\/([^/]+)\/poll$/);
+      if (threadSharePollMatch && req.method === "GET") {
+        const session = requireApiSession(req, res, config, state);
+        if (!session) return;
+        const token = cleanText(threadSharePollMatch[1]);
+        const share = runtime.threadSharesByToken.get(token);
+        if (!share) {
+          return writeJson(res, 404, { error: "not-found" });
+        }
+        if (share.decision) {
+          return writeJson(res, 200, { decision: share.decision, content: share.content });
+        }
+        const timeoutMs = Math.min(Number(url.searchParams.get("timeout")) || 120_000, 300_000);
+        await new Promise((resolve) => {
+          const timer = setTimeout(() => {
+            const idx = share.decisionWaiters.indexOf(done);
+            if (idx >= 0) share.decisionWaiters.splice(idx, 1);
+            resolve();
+          }, timeoutMs);
+          timer.unref?.();
+          function done(result) {
+            clearTimeout(timer);
+            resolve(result);
+          }
+          share.decisionWaiters.push(done);
+        });
+        if (share.decision) {
+          return writeJson(res, 200, { decision: share.decision, content: share.content });
+        }
+        return writeJson(res, 200, { decision: null, timeout: true });
+      }
+
       // Activity summary for compose (original post) drafting.
       // Supports ?slot=morning|noon|evening and ?date=YYYY-MM-DD for
       // time-slot-based compose.  Defaults to full-day today.
@@ -11432,6 +11815,27 @@ function createNativeApprovalServer({ config, runtime, state }) {
           return writeJson(res, 200, {});
         }
 
+        // Register Claude Code thread in persistent registry on every event.
+        {
+          const regThreadId = String(body.threadId || body.sessionId || "");
+          const regCwd = String(body.cwd || "");
+          if (regThreadId) {
+            const regLabel = runtime.claudeSessionTitles.get(regThreadId)
+              || (regCwd ? path.basename(regCwd) : "")
+              || regThreadId.slice(0, 40);
+            if (registerThread(runtime, {
+              id: regThreadId,
+              label: regLabel,
+              tool: "claude-code",
+              cwd: regCwd,
+              lastSeenAtMs: Date.now(),
+              active: eventType !== "Stop" && eventType !== "SessionEnd",
+            })) {
+              saveThreadRegistry(config.threadRegistryFile, runtime.threadRegistry).catch(() => {});
+            }
+          }
+        }
+
         if (eventType !== "approval_request") {
           // Non-approval events (Notification, Stop, etc.) — acknowledge immediately
           return writeJson(res, 200, {});
@@ -13828,6 +14232,7 @@ function buildConfig(cli) {
     historyFile: resolvePath(process.env.HISTORY_FILE || path.join(codexHome, "history.jsonl")),
     codexLogsDbFile: resolvePath(process.env.CODEX_LOGS_DB_FILE || ""),
     stateFile,
+    threadRegistryFile: resolvePath(process.env.THREAD_REGISTRY_FILE || path.join(os.homedir(), ".viveworker", "thread-registry.json")),
     replyUploadsDir: resolvePath(process.env.REPLY_UPLOADS_DIR || path.join(path.dirname(stateFile), "uploads")),
     timelineAttachmentsDir: resolvePath(
       process.env.TIMELINE_ATTACHMENTS_DIR || path.join(path.dirname(stateFile), "timeline-attachments")
@@ -14140,6 +14545,59 @@ async function saveState(stateFile, state) {
   await fs.writeFile(stateFile, `${output}\n`, "utf8");
 }
 
+// ---------------------------------------------------------------------------
+// Thread registry — persistent record of all known threads (survives restarts)
+// ---------------------------------------------------------------------------
+
+async function loadThreadRegistry(filePath) {
+  const registry = new Map();
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    const arr = JSON.parse(raw);
+    if (Array.isArray(arr)) {
+      for (const entry of arr) {
+        if (entry && entry.id) {
+          registry.set(entry.id, entry);
+        }
+      }
+    }
+  } catch {
+    // Missing or corrupt file — start with empty registry.
+  }
+  return registry;
+}
+
+async function saveThreadRegistry(filePath, registry) {
+  const arr = [...registry.values()].sort((a, b) => (b.lastSeenAtMs || 0) - (a.lastSeenAtMs || 0));
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, JSON.stringify(arr, null, 2) + "\n", "utf8");
+}
+
+/** Upsert a thread in the registry. Returns true if something changed. */
+function registerThread(runtime, entry) {
+  const existing = runtime.threadRegistry.get(entry.id);
+  const merged = {
+    id: entry.id,
+    label: entry.label || existing?.label || "",
+    tool: entry.tool || existing?.tool || "codex",
+    cwd: entry.cwd || existing?.cwd || "",
+    lastSeenAtMs: Math.max(entry.lastSeenAtMs || Date.now(), existing?.lastSeenAtMs || 0),
+    active: entry.active !== undefined ? entry.active : (existing?.active ?? true),
+  };
+  const changed = !existing
+    || existing.label !== merged.label
+    || existing.tool !== merged.tool
+    || existing.cwd !== merged.cwd
+    || existing.active !== merged.active
+    || existing.lastSeenAtMs !== merged.lastSeenAtMs;
+  if (changed) {
+    runtime.threadRegistry.set(entry.id, merged);
+  }
+  return changed;
+}
+
+// ---------------------------------------------------------------------------
+
 async function loadSessionIndex(filePath) {
   const result = new Map();
   try {

package/scripts/viveworker-claude-hook.mjs

@@ -107,8 +107,11 @@ switch (hookEventName) {
   case "PostToolUseFailure":
     await handlePostToolUse();
     break;
+  case "UserPromptSubmit":
+    await handleUserPromptSubmit();
+    break;
   default:
-    // Notification, Stop, UserPromptSubmit, SessionEnd
+    // Notification, Stop, SessionEnd
     await postEvent(hookEventName, { sessionId, toolName, cwd }, DEFAULT_EVENT_TIMEOUT_MS);
     break;
 }
@@ -399,6 +402,76 @@ async function handlePostToolUse() {
   );
 }
 
+// ---------------------------------------------------------------------------
+// UserPromptSubmit — thread inbox auto-read
+// ---------------------------------------------------------------------------
+
+async function handleUserPromptSubmit() {
+  // Check ~/.viveworker/thread-inbox/ for pending shared content from other
+  // AI tool sessions. If files are found, inject their content as additional
+  // context so the assistant sees them automatically.
+  //
+  // Targeting: if an inbox file has a `targetCwd` field, only consume it when
+  // the current session's cwd starts with that path (project match). Files
+  // without targetCwd are consumed by any session.
+  const inboxDir = path.join(os.homedir(), ".viveworker", "thread-inbox");
+  let inboxFiles = [];
+  try {
+    const entries = await fs.readdir(inboxDir);
+    inboxFiles = entries.filter((e) => e.endsWith(".json"));
+  } catch {
+    // Inbox dir doesn't exist or is unreadable — nothing to inject.
+  }
+
+  if (inboxFiles.length > 0) {
+    const parts = [];
+    for (const file of inboxFiles) {
+      const filePath = path.join(inboxDir, file);
+      try {
+        const raw = await fs.readFile(filePath, "utf8");
+        const share = JSON.parse(raw);
+        // Skip files targeted at a different project.
+        if (share.targetCwd && !cwd.startsWith(share.targetCwd)) {
+          continue;
+        }
+        const sourceLabel = share.sourceLabel || share.sourceTool || "another session";
+        const header = `[Shared from ${sourceLabel}]`;
+        let body = share.content || "";
+        // Append context file references if the content doesn't already include them.
+        const ctxFiles = Array.isArray(share.contextFiles) ? share.contextFiles.filter(Boolean) : [];
+        if (ctxFiles.length > 0 && !body.includes("Context files")) {
+          const fileList = ctxFiles.map((f) => `- ${f}`).join("\n");
+          body += `\n\n## Context files\n\nRead the following files for full conversation context:\n${fileList}`;
+        }
+        parts.push(`${header}\n\n${body}`);
+        // Mark as consumed by removing the file.
+        await fs.unlink(filePath);
+      } catch {
+        // Skip malformed or unreadable files.
+      }
+    }
+
+    if (parts.length > 0) {
+      // Cap at 10,000 chars (Claude Code hook output limit).
+      let combined = parts.join("\n\n---\n\n");
+      if (combined.length > 9800) {
+        combined = combined.slice(0, 9800) + "\n\n… (truncated)";
+      }
+      process.stdout.write(
+        JSON.stringify({
+          hookSpecificOutput: {
+            hookEventName: "UserPromptSubmit",
+            additionalContext: combined,
+          },
+        }) + "\n"
+      );
+    }
+  }
+
+  // Forward event to bridge as usual.
+  await postEvent("UserPromptSubmit", { sessionId, toolName, cwd }, DEFAULT_EVENT_TIMEOUT_MS);
+}
+
 // ---------------------------------------------------------------------------
 // Diff computation
 // ---------------------------------------------------------------------------

package/web/app.js

@@ -993,6 +993,9 @@ function shouldDeferRenderForActiveInteraction() {
   if (state.currentDetail?.kind === "moltbook_draft") {
     return true;
   }
+  if (state.currentDetail?.kind === "thread_share" && state.currentDetail?.threadShareEnabled) {
+    return true;
+  }
   if (
     activeElement instanceof HTMLTextAreaElement &&
     activeElement.matches("[data-claude-question-note]")
@@ -3459,14 +3462,15 @@ function renderStandardDetailDesktop(detail) {
     <div class="detail-shell">
       ${renderDetailMetaRow(detail, kindInfo)}
       <h2 class="detail-title detail-title--desktop">${renderDetailTitle(detail)}</h2>
-      ${detail.readOnly || detail.kind === "approval" || detail.kind === "moltbook_draft" || detail.kind === "moltbook_reply" ? "" : renderDetailLead(detail, kindInfo)}
+      ${detail.readOnly || detail.kind === "approval" || detail.kind === "moltbook_draft" || detail.kind === "moltbook_reply" || detail.kind === "thread_share" ? "" : renderDetailLead(detail, kindInfo)}
       ${renderPreviousContextCard(detail)}
       ${renderInterruptedDetailNotice(detail)}
       ${renderMoltbookReplyComposer(detail)}
       ${renderMoltbookDraftComposer(detail)}
       ${renderA2ATaskDetail(detail)}
+      ${renderThreadShareDetail(detail)}
       ${
-        detail.kind === "moltbook_draft" || detail.kind === "moltbook_reply" || detail.kind === "a2a_task"
+        detail.kind === "moltbook_draft" || detail.kind === "moltbook_reply" || detail.kind === "a2a_task" || detail.kind === "thread_share"
           ? ""
           : plainIntro
             ? plainIntro
@@ -3502,8 +3506,9 @@ function renderStandardDetailMobile(detail) {
           ${renderMoltbookReplyComposer(detail, { mobile: true })}
           ${renderMoltbookDraftComposer(detail, { mobile: true })}
           ${renderA2ATaskDetail(detail, { mobile: true })}
+          ${renderThreadShareDetail(detail, { mobile: true })}
           ${
-            detail.kind === "moltbook_draft" || detail.kind === "moltbook_reply" || detail.kind === "a2a_task"
+            detail.kind === "moltbook_draft" || detail.kind === "moltbook_reply" || detail.kind === "a2a_task" || detail.kind === "thread_share"
               ? ""
               : plainIntro
                 ? plainIntro
@@ -4112,6 +4117,56 @@ function renderA2ATaskDetail(detail, options = {}) {
   `;
 }
 
+function renderThreadShareDetail(detail, options = {}) {
+  if (detail.kind !== "thread_share") return "";
+  const enabled = detail.threadShareEnabled !== false && detail.readOnly !== true;
+  const content = detail.shareContent || "";
+  const fromLabel = detail.sourceLabel || detail.sourceTool || "agent";
+  const toLabel = detail.targetLabel || detail.targetConversationId?.slice(0, 8) || detail.targetTool || "thread";
+  const contextFiles = Array.isArray(detail.contextFiles) ? detail.contextFiles : [];
+  const shareTypeLabel = {
+    plan_review: L("threadShare.type.planReview"),
+    handoff: L("threadShare.type.handoff"),
+    message: L("threadShare.type.message"),
+  }[detail.shareType] || L("threadShare.type.message");
+
+  const contextFilesHtml = contextFiles.length > 0
+    ? `<div class="reply-composer__instruction">
+        <label class="field-label">${escapeHtml(L("threadShare.contextFiles"))}</label>
+        <ul class="context-files-list">${contextFiles.map((f) => `<li class="context-file-item"><code>${escapeHtml(f)}</code></li>`).join("")}</ul>
+      </div>`
+    : "";
+
+  const buttons = enabled
+    ? `
+      <div class="actions actions--stack${options.mobile ? " actions--sticky" : ""}">
+        <button type="submit" data-action="approve" class="primary primary--wide">${escapeHtml(L("threadShare.approve"))}</button>
+        <button type="submit" data-action="deny" class="danger danger--wide">${escapeHtml(L("threadShare.deny"))}</button>
+      </div>
+    `
+    : `<p class="muted reply-composer__description">${escapeHtml(L("threadShare.resolved"))}</p>`;
+  const buttonsWrapped = enabled && options.mobile ? `<div class="detail-action-bar">${buttons}</div>` : buttons;
+
+  return `
+    <section class="detail-card detail-card--reply ${options.mobile ? "detail-card--mobile" : ""}">
+      <form class="reply-composer" data-thread-share-form data-token="${escapeHtml(detail.token || "")}">
+        <div class="reply-composer__copy">
+          <span class="eyebrow-pill eyebrow-pill--quiet">${escapeHtml(L("threadShare.eyebrow"))}</span>
+          <span class="eyebrow-pill eyebrow-pill--subtle">${escapeHtml(shareTypeLabel)}</span>
+          <p class="reply-composer__author-meta muted">${escapeHtml(fromLabel)} → ${escapeHtml(toLabel)}</p>
+          <p class="muted reply-composer__description">${enabled ? escapeHtml(L("threadShare.editHint")) : ""}</p>
+        </div>
+        ${contextFilesHtml}
+        <div class="reply-composer__instruction">
+          <label class="field-label">${escapeHtml(L("threadShare.content"))}</label>
+          <textarea name="shareContent" class="reply-composer__textarea" rows="12" ${enabled ? "" : "readonly"}>${escapeHtml(content)}</textarea>
+        </div>
+        ${buttonsWrapped}
+      </form>
+    </section>
+  `;
+}
+
 function renderCompletionReplyComposer(detail, options = {}) {
   if (detail.kind !== "completion" || detail.reply?.enabled !== true) {
     return "";
@@ -5305,6 +5360,72 @@ function bindShellInteractions() {
     });
   }
 
+  const threadShareForm = document.querySelector("[data-thread-share-form]");
+  if (threadShareForm) {
+    const token = threadShareForm.dataset.token || "";
+    let submittedAction = "approve";
+    threadShareForm.querySelectorAll("button[type='submit']").forEach((btn) => {
+      btn.addEventListener("click", () => {
+        submittedAction = btn.dataset.action || "approve";
+      });
+    });
+    threadShareForm.addEventListener("submit", async (event) => {
+      event.preventDefault();
+      if (threadShareForm.dataset.submitting === "1") return;
+      threadShareForm.dataset.submitting = "1";
+      const buttons = threadShareForm.querySelectorAll("button[type='submit']");
+      const textarea = threadShareForm.querySelector("textarea");
+      const labelCache = new Map();
+      buttons.forEach((btn) => {
+        labelCache.set(btn, btn.innerHTML);
+        btn.disabled = true;
+        if (btn.dataset.action === submittedAction) {
+          btn.innerHTML = submittedAction === "approve" ? "Sharing…" : "Denying…";
+          btn.classList.add("is-loading");
+        } else {
+          btn.classList.add("is-dimmed");
+        }
+      });
+      if (textarea) textarea.readOnly = true;
+      const editedContent = normalizeClientText(new FormData(threadShareForm).get("shareContent"));
+      try {
+        const res = await fetch(`/api/threads/share/${encodeURIComponent(token)}/decision`, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          credentials: "same-origin",
+          body: JSON.stringify({ decision: submittedAction, editedContent }),
+        });
+        if (!res.ok) {
+          const errBody = await res.json().catch(() => ({}));
+          alert(`Thread share ${submittedAction} failed: ${errBody.error || res.status}`);
+          buttons.forEach((btn) => {
+            btn.disabled = false;
+            btn.classList.remove("is-loading", "is-dimmed");
+            btn.innerHTML = labelCache.get(btn);
+          });
+          if (textarea) textarea.readOnly = false;
+          threadShareForm.dataset.submitting = "";
+          return;
+        }
+        if (state.currentDetail?.kind === "thread_share") {
+          state.currentDetail.threadShareEnabled = false;
+          state.currentDetail.readOnly = true;
+        }
+        await refreshAuthenticatedState();
+        await renderShell();
+      } catch (error) {
+        alert(`Thread share error: ${error.message}`);
+        buttons.forEach((btn) => {
+          btn.disabled = false;
+          btn.classList.remove("is-loading", "is-dimmed");
+          btn.innerHTML = labelCache.get(btn);
+        });
+        if (textarea) textarea.readOnly = false;
+        threadShareForm.dataset.submitting = "";
+      }
+    });
+  }
+
   const replyForm = document.querySelector("[data-completion-reply-form]");
   if (replyForm) {
     const token = replyForm.dataset.token || "";
@@ -5786,6 +5907,8 @@ function kindMeta(kind) {
     case "moltbook_reply":
     case "moltbook_draft":
       return { label: L("common.sns"), tone: "neutral", icon: "item" };
+    case "thread_share":
+      return { label: L("common.threadShare"), tone: "neutral", icon: "link" };
     default:
       return { label: L("common.item"), tone: "neutral", icon: "item" };
   }

package/web/i18n.js

@@ -49,6 +49,7 @@ const translations = {
     "common.assistantFinal": "Final reply",
     "common.item": "Item",
     "common.sns": "SNS",
+    "common.threadShare": "Thread Share",
     "common.untitledItem": "Untitled item",
     "common.useDeviceLanguage": "Use device language",
     "language.option.en": "English",
@@ -400,6 +401,16 @@ const translations = {
     "a2a.task.statusFailed": "Failed",
     "a2a.task.statusCanceled": "Canceled",
     "a2a.task.statusRejected": "Rejected",
+    "threadShare.eyebrow": "Thread Share",
+    "threadShare.content": "Shared content",
+    "threadShare.approve": "Approve & Share",
+    "threadShare.deny": "Deny",
+    "threadShare.editHint": "Review the content below. Edit if needed, then approve to share or deny to skip.",
+    "threadShare.resolved": "This share request has been resolved.",
+    "threadShare.contextFiles": "Context files (read by recipient)",
+    "threadShare.type.message": "Message",
+    "threadShare.type.planReview": "Plan Review",
+    "threadShare.type.handoff": "Handoff",
     "notice.notificationsEnabled": "Notifications are enabled on this device.",
     "notice.notificationsDisabled": "Notifications are disabled on this device.",
     "notice.testNotificationSent": "Test notification sent.",
@@ -666,6 +677,7 @@ const translations = {
     "common.assistantFinal": "最終回答",
     "common.item": "項目",
     "common.sns": "SNS",
+    "common.threadShare": "スレッド共有",
     "common.untitledItem": "無題の項目",
     "common.useDeviceLanguage": "端末の言語を使う",
     "language.option.en": "English",
@@ -1013,6 +1025,16 @@ const translations = {
     "a2a.task.statusFailed": "失敗",
     "a2a.task.statusCanceled": "キャンセル",
     "a2a.task.statusRejected": "拒否済み",
+    "threadShare.eyebrow": "スレッド共有",
+    "threadShare.content": "共有内容",
+    "threadShare.approve": "承認して共有",
+    "threadShare.deny": "拒否",
+    "threadShare.editHint": "内容を確認してください。必要に応じて編集し、承認で共有、拒否でスキップします。",
+    "threadShare.resolved": "この共有リクエストは処理済みです。",
+    "threadShare.contextFiles": "コンテキストファイル（受信側が読み込みます）",
+    "threadShare.type.message": "メッセージ",
+    "threadShare.type.planReview": "プランレビュー",
+    "threadShare.type.handoff": "引き継ぎ",
     "notice.notificationsEnabled": "この端末で通知を有効にしました。",
     "notice.notificationsDisabled": "この端末の通知を無効にしました。",
     "notice.testNotificationSent": "テスト通知を送信しました。",