@chainingintention/pi-web-cn 1.202610.0 → 1.202610.2

package/dist/pi-packages/captains-log/dist/browser/panel.js

@@ -0,0 +1,151 @@
+// Generated from pi-packages/captains-log/src/browser/panel.ts. Do not edit directly.
+import { renderCaptainMarkdown } from "./markdown.js";
+export function selectedSourceSession(context) {
+    if (context.state?.selectedMachine && context.state.selectedMachine.id !== context.machine.id)
+        return;
+    const selected = context.state?.selectedSession;
+    if (!selected || selected.archived || selected.pending || selected.cwd !== context.workspace.path)
+        return;
+    return { id: selected.id, name: selected.name !== undefined && selected.name.trim() !== "" ? selected.name : `会话 ${selected.id.slice(0, 8)}` };
+}
+export function captainStatusLabel(status) {
+    return { running: "处理中", completed: "已完成", failed: "失败", interrupted: "已中断" }[status];
+}
+const stageLabels = {
+    "Backend admitted translation": "后端已接收转述请求",
+    "Backend sent request to native companion": "后端已向原生伴随扩展发送请求",
+    "Native companion received request": "原生伴随扩展已收到请求",
+    "Native Pi agent running": "原生 Pi 代理正在运行",
+    "Backend received correlated final reply": "后端已收到匹配请求的最终回复",
+    "Source reply read without changing source": "已读取源回复，未改动源会话",
+    "Pirate conversation selected": "已选择船长会话",
+    "Backend recorded failure (not success)": "后端已记录失败，不是成功结果",
+    "Backend saved completed roundtrip": "后端已保存完成结果",
+};
+const errorLabels = {
+    "Captain is already working.": "船长正在处理，请等待当前转述完成。",
+    "Select a source session other than the pirate conversation.": "请选择其他源会话，不能转述船长会话本身。",
+    "Selected session is not hosted in this workspace on this machine": "所选会话不在当前机器的这个工作区中运行。",
+    "Source session must be idle with no pending messages. Wait for it to finish, then translate again.": "源会话必须空闲且没有待处理消息。请等待它完成后再转述。",
+    "Source session has no completed assistant text reply on its active branch.": "源会话当前分支没有已完成的助手文本回复。",
+    "Source reply exceeds the translation limit (48000 characters).": "源回复超过转述长度上限（48000 个字符）。",
+    "Companion not ready or session busy; open Captain's Log in Sessions, wait for idle, then retry": "伴随扩展尚未就绪或会话忙碌；请在会话列表中打开船长会话，等待空闲后重试。",
+    "Captain request interrupted by session shutdown or reload": "会话关闭或重新加载中断了船长请求。",
+    "Another prompt interfered with this Captain request; translation was not saved": "其他提示干扰了本次船长请求，转述结果未保存。",
+    "Another user message interfered with this Captain request": "其他用户消息干扰了本次船长请求。",
+    "Captain request error": "船长请求出错。",
+    "Captain request aborted": "船长请求已中止。",
+    "Captain request failed": "船长请求失败。",
+    "Captain request ended without a successful final text response": "船长请求结束时没有成功的最终文本回复。",
+    "Captain reply exceeded the storage limit": "船长回复超过存储长度上限。",
+    "Invalid translation text": "转述文本无效。",
+    "Invalid companion reply": "伴随扩展回复无效。",
+    "Captain connection interrupted; agent work may continue in Sessions": "船长连接已中断，代理可能仍在会话中继续处理。",
+    "No companion receipt within 5 seconds. Check package enablement/trust; inspect Sessions before retrying.": "5 秒内未收到伴随扩展确认。请检查包是否已启用并获得信任，重试前先查看会话。",
+    "Captain request exceeded 10 minutes; agent work may continue in Sessions. No translation saved.": "船长请求已超过 10 分钟，代理可能仍在会话中继续处理；转述结果未保存。",
+    "Captain's Log stopped before recording completion. Inspect the previous session before retrying. Nothing was resent automatically.": "船长日志在记录完成结果前已停止。请先检查之前的会话再重试，没有自动重发任何请求。",
+};
+function displayCaptainError(text) {
+    const prefix = "Captain could not finish this request. Inspect the session before retrying; nothing was resent automatically.\n";
+    if (text.startsWith(prefix))
+        return `船长未能完成本次请求。重试前请检查会话，没有自动重发任何请求。\n${displayCaptainError(text.slice(prefix.length))}`;
+    const message = text.startsWith("Error: ") ? text.slice(7) : text;
+    return errorLabels[message] ?? text;
+}
+function dateLabel(value) {
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? value : date.toLocaleString(undefined, { month: "short", day: "numeric", hour: "2-digit", minute: "2-digit" });
+}
+export function renderCaptainPanel(html, view) {
+    const working = view.entries.some((entry) => entry.status === "running");
+    const pirateSelected = view.source !== undefined && view.entries.some((entry) => entry.sessionId === view.source?.id);
+    const disabled = !view.connected || view.connecting || view.pending || working || !view.source || pirateSelected;
+    const selected = view.selected;
+    const sourceSessionId = selected?.sourceSessionId;
+    const status = view.connecting ? "连接中…" : !view.connected ? "连接已断开" : view.pending ? "正在读取最后一条回复…"
+        : working ? "船长正在转述…" : !view.source ? "请先选择当前工作区中的会话。" : pirateSelected ? "请选择其他会话，当前会话是船长会话。"
+            : "可以开始转述";
+    return html `<style>${styles}</style>
+    <section class="captains-log" aria-label="船长日志">
+      <div class="captain-heading"><h2>⚓ 船长日志</h2><p class="muted">让戏剧化的海盗船长转述最后一条回复。</p></div>
+      <div class="captain-source"><span class="muted">选中会话</span><strong>${view.source?.name ?? "未选择会话"}</strong></div>
+      <button class="captain-primary" ?disabled=${disabled} @click=${view.onTranslate}>让船长转述</button>
+      <p class="captain-status" role="status" aria-live="polite">${status}
+        ${!view.connected && !view.connecting ? html `<button @click=${view.onReconnect}>重新连接</button>` : null}
+      </p>
+      ${!view.connected && !view.connecting ? html `<p class="captain-notice">重新连接以查看结果。船长可能仍在处理，不会再次发送你的请求。</p>` : null}
+      ${view.notice !== undefined && view.notice !== "" ? html `<p class="captain-notice" role="alert">${displayCaptainError(view.notice)}</p>` : null}
+      ${selected ? html `<article class="captain-reply" aria-label="船长转述">
+        <div class="captain-reply-heading"><strong>${selected.status === "running" ? "转述中…" : selected.id === view.entries[0]?.id ? "最近转述" : "历史转述"}</strong><time datetime=${selected.createdAt}>${dateLabel(selected.createdAt)}</time></div>
+        ${selected.status === "completed" ? html `<div class="captain-answer">${selected.text ? renderCaptainMarkdown(html, selected.text) : "正在接收船长回复…"}</div>`
+        : selected.status === "running" ? html `<p class="muted">正在读取源回复并改写为海盗风格，不向源会话发送消息。</p>`
+            : html `<div class="captain-notice" role="alert"><strong>${selected.status === "interrupted" ? "转述已中断" : "无法转述该回复"}</strong><p>${displayCaptainError(selected.text) || "请查看诊断详情，待会话就绪后重试。"}</p></div>`}
+        ${sourceSessionId !== undefined && sourceSessionId !== "" ? html `<button @click=${() => { view.onOpenSource(sourceSessionId); }}>打开源会话</button>` : null}
+      </article>` : html `<p class="captain-empty muted">选择会话后转述其最新已完成的助手回复，原会话保持不变。</p>`}
+      <div class="captain-secondary">
+        ${view.entries.length > 1 ? html `<details><summary>历史转述 <span class="muted">(${view.entries.length})</span></summary>
+          <div class="captain-history">${view.entries.map((entry) => html `<button class=${entry.id === selected?.id ? "selected" : ""} ?disabled=${!view.connected} @click=${() => { view.onRead(entry.id); }}>
+            <span>${dateLabel(entry.createdAt)} · ${entry.status === "completed" ? "已转述" : entry.status === "running" ? "处理中" : "未完成"}</span>
+          </button>`)}</div>
+        </details>` : null}
+        <details class="captain-diagnostics"><summary>诊断</summary>
+          <p>${displayCaptainError(view.status)}</p>
+          ${selected ? html `<dl><dt>机器</dt><dd>${view.machineName}</dd><dt>源会话</dt><dd>${selected.sourceSessionId ?? "未知"}</dd><dt>船长会话</dt><dd>${selected.sessionId || "尚未创建"}</dd><dt>请求</dt><dd>${selected.id}</dd></dl>
+            <p>${selected.question === "Translate last reply" ? "转述最后一条回复" : selected.question}</p><ol>${selected.stages.map((stage) => html `<li>${stageLabels[stage] ?? stage}</li>`)}</ol>` : null}
+        </details>
+        <p class="captain-footnote muted">使用你配置的模型，可能产生费用。可用时复用船长会话，否则自动创建。</p>
+      </div>
+    </section>`;
+}
+// Light DOM inherits workspace typography/buttons. Extra rules are package-scoped and use host themes.
+const styles = `
+  captains-log-lifetime { display: block; min-width: 0; }
+  .captains-log { box-sizing: border-box; padding: 16px; min-width: 0; color: inherit; font: inherit; line-height: 1.5; }
+  .captains-log *, .captains-log *::before, .captains-log *::after { box-sizing: border-box; }
+  .captains-log h2, .captains-log p { margin: 0; }
+  .captains-log h2 { font-size: 15px; }
+  .captains-log button { font: inherit; }
+  .captains-log button:hover:not(:disabled) { background: var(--pi-surface-hover); }
+  .captains-log button:disabled { opacity: .5; cursor: not-allowed; }
+  .captains-log button:focus-visible, .captains-log summary:focus-visible { outline: 2px solid var(--pi-accent); outline-offset: 2px; }
+  .captains-log .captain-primary { border-color: var(--pi-accent-border); background: var(--pi-selection-bg); padding: 8px 12px; }
+  .captains-log .captain-source { display: grid; gap: 3px; margin: 18px 0 12px; padding: 10px 12px; background: var(--pi-surface); border: 1px solid var(--pi-border-muted); border-radius: 8px; overflow-wrap: anywhere; }
+  .captains-log .captain-source span { font-size: 11px; }
+  .captains-log .captain-status { display: flex; align-items: center; flex-wrap: wrap; gap: 8px; margin: 10px 0 16px; color: var(--pi-muted); font-size: 12px; }
+  .captains-log .captain-notice { padding: 12px; margin-bottom: 12px; border: 1px solid var(--pi-warning-border); border-radius: 8px; background: var(--pi-warning-surface); overflow-wrap: anywhere; white-space: pre-wrap; }
+  .captains-log .captain-notice p { margin-top: 6px; }
+  .captains-log .captain-empty { padding: 16px 0; }
+  .captains-log .captain-reply { padding: 16px 0; border-top: 1px solid var(--pi-border-muted); }
+  .captains-log .captain-reply-heading { display: flex; align-items: center; justify-content: space-between; gap: 12px; margin-bottom: 10px; }
+  .captains-log time { color: var(--pi-muted); font-size: 11px; }
+  .captains-log .captain-answer { line-height: 1.65; overflow-wrap: anywhere; min-width: 0; }
+  .captains-log .captain-answer > :first-child { margin-top: 0; }
+  .captains-log .captain-answer > :last-child { margin-bottom: 0; }
+  .captains-log .captain-answer p, .captains-log .captain-answer ul, .captains-log .captain-answer ol { margin: .65em 0; }
+  .captains-log .captain-answer h1, .captains-log .captain-answer h2, .captains-log .captain-answer h3,
+  .captains-log .captain-answer h4, .captains-log .captain-answer h5, .captains-log .captain-answer h6 { margin: 1em 0 .4em; line-height: 1.3; }
+  .captains-log .captain-answer h1 { font-size: 1.5em; }
+  .captains-log .captain-answer h2 { font-size: 1.3em; }
+  .captains-log .captain-answer h3 { font-size: 1.15em; }
+  .captains-log .captain-answer ul, .captains-log .captain-answer ol { padding-left: 1.7em; }
+  .captains-log .captain-answer blockquote { margin: .75em 0; padding-left: 1em; border-left: 3px solid var(--pi-border-muted); color: var(--pi-muted); }
+  .captains-log .captain-answer code { font-family: monospace; background: var(--pi-surface); border-radius: 3px; padding: .1em .25em; }
+  .captains-log .captain-answer pre { max-width: 100%; overflow: auto; padding: 12px; background: var(--pi-surface); border: 1px solid var(--pi-border-muted); border-radius: 6px; white-space: pre; overflow-wrap: normal; }
+  .captains-log .captain-answer pre code { padding: 0; background: none; }
+  .captains-log .captain-answer a { color: var(--pi-accent); text-decoration: underline; }
+  .captains-log .captain-answer a:focus-visible { outline: 2px solid var(--pi-accent); outline-offset: 2px; }
+  .captains-log .captain-table-scroll { max-width: 100%; overflow: auto; margin: .75em 0; }
+  .captains-log .captain-answer table { border-collapse: collapse; width: 100%; }
+  .captains-log .captain-answer th, .captains-log .captain-answer td { border: 1px solid var(--pi-border-muted); padding: 6px 10px; text-align: left; }
+  .captains-log .captain-answer th { background: var(--pi-surface); }
+  .captains-log .captain-answer hr { border: 0; border-top: 1px solid var(--pi-border-muted); }
+  .captains-log .captain-secondary { border-top: 1px solid var(--pi-border-muted); margin-top: 12px; padding-top: 6px; }
+  .captains-log details { padding: 8px 0; }
+  .captains-log summary { cursor: pointer; color: var(--pi-muted); }
+  .captains-log details p { margin: 8px 0; overflow-wrap: anywhere; }
+  .captains-log .captain-history { display: grid; gap: 6px; padding-top: 8px; }
+  .captains-log .captain-history button { text-align: left; min-width: 0; }
+  .captains-log dl { display: grid; grid-template-columns: auto minmax(0, 1fr); gap: 4px 10px; font-size: 11px; }
+  .captains-log dd { margin: 0; overflow-wrap: anywhere; }
+  .captains-log .captain-footnote { font-size: 11px; margin-top: 10px; }
+`;

package/dist/pi-packages/captains-log/dist/browser/protocol.js

@@ -0,0 +1,26 @@
+// Generated from pi-packages/captains-log/src/browser/protocol.ts. Do not edit directly.
+export const CAPTAIN_REQUEST = "captains-log:v1:request";
+export const CAPTAIN_REPLY = "captains-log:v1:reply";
+export const SOURCE_REQUEST = "captains-log:v1:source-request";
+export const SOURCE_REPLY = "captains-log:v1:source-reply";
+export const PIRATE_INTRO = "We are pirates. Always speak pirate.";
+export const PIRATE_MARKER = "captains-log:pirate-introduced";
+export const MAX_FINDINGS = 48_000;
+export const MAX_QUESTION = 8_000;
+export const UUID = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+export function isLogEntry(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    return "id" in value && typeof value.id === "string" && UUID.test(value.id)
+        && "createdAt" in value && typeof value.createdAt === "string"
+        && "sessionId" in value && typeof value.sessionId === "string" && value.sessionId.length <= 512
+        && (!("sourceSessionId" in value) || value.sourceSessionId === undefined || (typeof value.sourceSessionId === "string" && !!value.sourceSessionId.trim() && value.sourceSessionId.length <= 512))
+        && "question" in value && typeof value.question === "string" && value.question.length <= MAX_QUESTION
+        && "status" in value && ["running", "completed", "failed", "interrupted"].includes(String(value.status))
+        && (!("failureCode" in value) || value.failureCode === undefined || (typeof value.failureCode === "string" && ["session-unavailable", "request-failed", "interrupted"].includes(value.failureCode)))
+        && "stages" in value && Array.isArray(value.stages) && value.stages.length <= 16 && value.stages.every((s) => typeof s === "string" && s.length <= 256)
+        && "text" in value && typeof value.text === "string" && value.text.length <= MAX_FINDINGS;
+}
+export function captainPrompt(text) {
+    return `Retell this as a theatrical pirate captain briefing the crew. Rewrite it from scratch: nautical metaphors, colorful pirate phrasing, and a little humor. Preserve the important facts, warnings, and next steps; keep code and commands exact. Don't merely sprinkle “arrr” onto the original. Always speak pirate.\n\nSource reply:\n${text}`;
+}

package/dist/pi-packages/captains-log/dist/companion.js

@@ -0,0 +1,126 @@
+// Generated from pi-packages/captains-log/src/companion.ts. Do not edit directly.
+import { MAX_FINDINGS, UUID, CAPTAIN_REPLY, CAPTAIN_REQUEST, SOURCE_REQUEST, SOURCE_REPLY, PIRATE_INTRO, PIRATE_MARKER, captainPrompt } from "./browser/protocol.js";
+export default function companion(pi) {
+    let context;
+    let active;
+    const reply = (requestId, result) => { pi.events.emit(CAPTAIN_REPLY, { requestId, ...result }); };
+    pi.on("session_start", (_event, ctx) => { context = ctx; });
+    pi.on("session_shutdown", () => {
+        if (active)
+            reply(active.requestId, { status: "failed", error: "Captain request interrupted by session shutdown or reload" });
+        active = undefined;
+        context = undefined;
+    });
+    pi.on("before_agent_start", (event) => {
+        if (!active)
+            return;
+        if (!active.started && event.prompt === active.prompt) {
+            active.started = true;
+            if (event.prompt === PIRATE_INTRO)
+                pi.appendEntry(PIRATE_MARKER, {});
+            reply(active.requestId, { status: "running" });
+        }
+        else
+            active.error = "Another prompt interfered with this Captain request; translation was not saved";
+    });
+    pi.on("message_start", (event) => {
+        if (!active || event.message.role !== "user")
+            return;
+        const content = event.message.content;
+        const text = typeof content === "string" ? content : content.filter((part) => part.type === "text").map((part) => part.text).join("");
+        if (text !== active.prompt)
+            active.error = "Another user message interfered with this Captain request";
+    });
+    pi.on("tool_result", (event) => {
+        if (active?.started === true && event.isError)
+            active.error = `Captain tool failed: ${event.toolName}. Inspect the conversation and retry explicitly.`;
+    });
+    pi.on("message_end", (event) => {
+        if (active?.started !== true || event.message.role !== "assistant")
+            return;
+        active.text = event.message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+        active.stopReason = event.message.stopReason;
+        if (event.message.stopReason === "error" || event.message.stopReason === "aborted") {
+            active.error = event.message.errorMessage ?? `Captain request ${event.message.stopReason}`;
+        }
+    });
+    // agent_end can precede automatic retries/compaction. Settlement is the final boundary.
+    pi.on("agent_settled", () => {
+        if (active?.started !== true)
+            return;
+        const result = active;
+        active = undefined;
+        const error = result.error ?? (result.stopReason !== "stop" || !result.text.trim()
+            ? "Captain request ended without a successful final text response" : result.text.length > MAX_FINDINGS
+            ? "Captain reply exceeded the storage limit" : undefined);
+        if (error === undefined && result.nextPrompt !== undefined) {
+            active = { requestId: result.requestId, prompt: result.nextPrompt, started: false, text: "", stopReason: "" };
+            try {
+                pi.sendUserMessage(active.prompt);
+            }
+            catch (failure) {
+                active = undefined;
+                reply(result.requestId, { status: "failed", error: String(failure) });
+            }
+            return;
+        }
+        reply(result.requestId, error !== undefined ? { status: "failed", error } : { status: "completed", text: result.text });
+    });
+    // Read only this companion's active branch; never prompt, rename, or append to the source.
+    pi.events.on(SOURCE_REQUEST, (data) => {
+        if (typeof data !== "object" || data === null || !("requestId" in data)
+            || typeof data.requestId !== "string" || !UUID.test(data.requestId))
+            return;
+        const respond = (result) => { pi.events.emit(SOURCE_REPLY, { requestId: data.requestId, ...result }); };
+        try {
+            if (!context || active || !context.isIdle() || context.hasPendingMessages())
+                throw new Error("Source session must be idle with no pending messages. Wait for it to finish, then translate again.");
+            if (context.sessionManager.getEntries().some((entry) => entry.type === "custom" && (entry.customType === PIRATE_MARKER || entry.customType === "captains-log:request")))
+                throw new Error("Select a source session other than the pirate conversation.");
+            for (const entry of [...context.sessionManager.getBranch()].reverse()) {
+                if (entry.type !== "message" || entry.message.role !== "assistant" || entry.message.stopReason !== "stop")
+                    continue;
+                const text = entry.message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+                if (!text.trim())
+                    continue;
+                if (text.length > MAX_FINDINGS)
+                    throw new Error("Source reply exceeds the translation limit (48000 characters).");
+                respond({ status: "completed", text });
+                return;
+            }
+            throw new Error("Source session has no completed assistant text reply on its active branch.");
+        }
+        catch (error) {
+            respond({ status: "failed", error: error instanceof Error ? error.message : String(error) });
+        }
+    });
+    // Pi owns listeners and replaces them on /reload. No background resources at load time.
+    pi.events.on(CAPTAIN_REQUEST, (data) => {
+        if (typeof data !== "object" || data === null || !("requestId" in data)
+            || typeof data.requestId !== "string" || !UUID.test(data.requestId))
+            return;
+        if (!("text" in data) || typeof data.text !== "string" || !data.text.trim() || data.text.length > MAX_FINDINGS) {
+            reply(data.requestId, { status: "failed", error: "Invalid translation text" });
+            return;
+        }
+        const { requestId } = data;
+        if (!context || active || !context.isIdle() || context.hasPendingMessages()) {
+            reply(requestId, { status: "failed", error: "Companion not ready or session busy; open Captain's Log in Sessions, wait for idle, then retry" });
+            return;
+        }
+        const introduced = context.sessionManager.getEntries().some((entry) => entry.type === "custom" && entry.customType === PIRATE_MARKER);
+        const translation = captainPrompt(data.text);
+        const prompt = introduced ? translation : PIRATE_INTRO;
+        active = { requestId, prompt, ...(introduced ? {} : { nextPrompt: translation }), started: false, text: "", stopReason: "" };
+        try {
+            pi.setSessionName("Captain's Log");
+            pi.appendEntry("captains-log:request", { requestId });
+            reply(requestId, { status: "accepted" });
+            pi.sendUserMessage(prompt);
+        }
+        catch (error) {
+            active = undefined;
+            reply(requestId, { status: "failed", error: error instanceof Error ? error.message : String(error) });
+        }
+    });
+}

package/dist/pi-packages/captains-log/dist/roundtrip.js

@@ -0,0 +1,62 @@
+// Generated from pi-packages/captains-log/src/roundtrip.ts. Do not edit directly.
+import { MAX_FINDINGS, CAPTAIN_REPLY, CAPTAIN_REQUEST, SOURCE_REPLY, SOURCE_REQUEST } from "./browser/protocol.js";
+export function collectReply(connection, requestId, text, lifetime, progress) {
+    return collect(connection, requestId, { requestId, text }, CAPTAIN_REQUEST, CAPTAIN_REPLY, lifetime, progress);
+}
+export function collectSourceReply(connection, requestId, lifetime, progress) {
+    return collect(connection, requestId, { requestId }, SOURCE_REQUEST, SOURCE_REPLY, lifetime, progress);
+}
+/** Subscribe before sending. Never retry an ambiguous send or cancel Pi on timeout. */
+async function collect(connection, requestId, payload, requestEvent, replyEvent, lifetime, progress) {
+    const signal = AbortSignal.any([lifetime, connection.signal]);
+    signal.throwIfAborted();
+    let unsubscribe;
+    let onAbort;
+    let receiptTimer;
+    let completionTimer;
+    try {
+        return await new Promise((resolve, reject) => {
+            onAbort = () => { reject(new Error("Captain connection interrupted; agent work may continue in Sessions")); };
+            signal.addEventListener("abort", onAbort, { once: true });
+            receiptTimer = setTimeout(() => { reject(new Error("No companion receipt within 5 seconds. Check package enablement/trust; inspect Sessions before retrying.")); }, 5_000);
+            completionTimer = setTimeout(() => { reject(new Error("Captain request exceeded 10 minutes; agent work may continue in Sessions. No translation saved.")); }, 600_000);
+            unsubscribe = connection.on(replyEvent, (data) => {
+                if (typeof data !== "object" || data === null || !("requestId" in data) || data.requestId !== requestId)
+                    return;
+                if (!("status" in data))
+                    return;
+                if (data.status === "accepted") {
+                    clearTimeout(receiptTimer);
+                    progress("Native companion received request");
+                    return;
+                }
+                if (data.status === "running") {
+                    progress("Native Pi agent running");
+                    return;
+                }
+                if (data.status === "failed") {
+                    reject(new Error("error" in data && typeof data.error === "string" ? data.error.slice(0, 4000) : "Captain request failed"));
+                }
+                else if (data.status === "completed") {
+                    if (!("text" in data) || typeof data.text !== "string" || !data.text.trim() || data.text.length > MAX_FINDINGS) {
+                        reject(new Error("Invalid companion reply"));
+                    }
+                    else {
+                        progress("Backend received correlated final reply");
+                        resolve(data.text);
+                    }
+                }
+            });
+            // Native listeners can reply synchronously.
+            progress("Backend sent request to native companion");
+            connection.emit(requestEvent, payload);
+        });
+    }
+    finally {
+        clearTimeout(receiptTimer);
+        clearTimeout(completionTimer);
+        if (onAbort)
+            signal.removeEventListener("abort", onAbort);
+        unsubscribe?.();
+    }
+}

package/dist/pi-packages/captains-log/dist/server.js

@@ -0,0 +1,210 @@
+// Generated from pi-packages/captains-log/src/server.ts. Do not edit directly.
+import { randomUUID } from "node:crypto";
+import { PI_WEB_HOST_PI_SESSIONS_CAPABILITY, PI_WEB_HOST_PI_SESSION_EVENTS_CAPABILITY } from "@chainingintention/pi-web-cn/server-plugin-api";
+import {} from "./browser/protocol.js";
+import { LOG_CHANNEL, entryFrames, isCaptainClientFrame } from "./browser/channelProtocol.js";
+import { collectReply, collectSourceReply } from "./roundtrip.js";
+import { LogStore, logScope } from "./store.js";
+const plugin = {
+    apiVersion: 3,
+    name: "Captain's Log",
+    requires: [PI_WEB_HOST_PI_SESSIONS_CAPABILITY, PI_WEB_HOST_PI_SESSION_EVENTS_CAPABILITY],
+    activate(host) {
+        const store = new LogStore(host.dataDirectory);
+        const active = new Map();
+        const unsaved = new Map();
+        const currentSessions = new Map();
+        const subscribers = new Map();
+        const channelCleanups = new Set();
+        function publish(scope, entry, saved) {
+            for (const frame of entryFrames(entry, saved))
+                for (const send of subscribers.get(scope) ?? [])
+                    send(frame);
+        }
+        const tasks = new Set();
+        let sessions;
+        let events;
+        function visible(scope, entry) {
+            const live = active.get(scope);
+            if (live?.id === entry.id)
+                return live;
+            return unsaved.get(entry.id) ?? (entry.status === "running"
+                ? { ...entry, status: "interrupted", failureCode: "interrupted", text: "Captain's Log stopped before recording completion. Inspect the previous session before retrying. Nothing was resent automatically." }
+                : entry);
+        }
+        return {
+            start({ capabilities }) {
+                sessions = capabilities.resolve(PI_WEB_HOST_PI_SESSIONS_CAPABILITY);
+                events = capabilities.resolve(PI_WEB_HOST_PI_SESSION_EVENTS_CAPABILITY);
+            },
+            peer: {
+                async request(context) {
+                    context.signal.throwIfAborted();
+                    host.lifetimeSignal.throwIfAborted();
+                    const selection = { projectId: context.project.id, workspaceId: context.workspace.id };
+                    const scope = logScope(selection.projectId, selection.workspaceId);
+                    if (context.operation === "list") {
+                        const entries = (await store.list(scope)).map((entry) => visible(scope, entry));
+                        const live = active.get(scope);
+                        if (live && !entries.some((entry) => entry.id === live.id))
+                            entries.unshift(live);
+                        return entries.map((entry) => ({ ...entry, text: "" }));
+                    }
+                    if (context.operation === "read") {
+                        const live = active.get(scope);
+                        return { ...(live?.id === context.input ? live : visible(scope, await store.read(scope, context.input))) };
+                    }
+                    throw new Error("Unknown Captain operation (translations require the log channel)");
+                },
+                openChannel(context) {
+                    context.signal.throwIfAborted();
+                    host.lifetimeSignal.throwIfAborted();
+                    if (context.operation !== LOG_CHANNEL || context.input !== null)
+                        throw new Error("Invalid Captain channel open");
+                    const selection = { projectId: context.project.id, workspaceId: context.workspace.id };
+                    const scope = logScope(selection.projectId, selection.workspaceId);
+                    let listening = true;
+                    const send = (frame) => {
+                        if (!listening)
+                            return;
+                        try {
+                            context.send(frame.type === "entry" ? { ...frame, entry: { ...frame.entry } } : frame);
+                        }
+                        catch (error) {
+                            cleanup();
+                            host.logger.warn(`Captain subscriber disconnected: ${String(error)}`);
+                        }
+                    };
+                    const cleanup = () => {
+                        listening = false;
+                        subscribers.get(scope)?.delete(send);
+                        if ((subscribers.get(scope)?.size ?? 0) === 0)
+                            subscribers.delete(scope);
+                        context.signal.removeEventListener("abort", cleanup);
+                        host.lifetimeSignal.removeEventListener("abort", cleanup);
+                        channelCleanups.delete(cleanup);
+                    };
+                    if (!subscribers.has(scope))
+                        subscribers.set(scope, new Set());
+                    subscribers.get(scope)?.add(send);
+                    context.signal.addEventListener("abort", cleanup, { once: true });
+                    host.lifetimeSignal.addEventListener("abort", cleanup, { once: true });
+                    channelCleanups.add(cleanup);
+                    return {
+                        close: cleanup,
+                        async receive(data, signal) {
+                            signal.throwIfAborted();
+                            host.lifetimeSignal.throwIfAborted();
+                            if (!isCaptainClientFrame(data))
+                                throw new Error("Invalid Captain translation frame");
+                            const reject = (message) => { send({ type: "rejected", requestId: data.requestId, message: message.slice(0, 2000) }); };
+                            if (active.has(scope)) {
+                                reject("Captain is already working.");
+                                return;
+                            }
+                            const entry = { id: randomUUID(), createdAt: new Date().toISOString(), sessionId: "", question: "Translate last reply", sourceSessionId: data.sourceSessionId, status: "running", stages: ["Backend admitted translation"], text: "Preparing Captain's Log…" };
+                            // Lock before any I/O so concurrent tabs cannot create two dedicated sessions.
+                            active.set(scope, entry);
+                            try {
+                                const previous = await store.list(scope);
+                                // Strictly increasing admission times make persisted session selection independent of UUID ties.
+                                const latestTime = Math.max(0, ...previous.map((record) => Date.parse(record.createdAt)).filter(Number.isFinite));
+                                entry.createdAt = new Date(Math.max(Date.now(), latestTime + 1)).toISOString();
+                                entry.sessionId = currentSessions.get(scope) ?? previous.find((record) => record.sessionId)?.sessionId ?? "";
+                                if (entry.sessionId === data.sourceSessionId || previous.some((record) => record.sessionId === data.sourceSessionId))
+                                    throw new Error("Select a source session other than the pirate conversation.");
+                                await store.save(scope, entry);
+                            }
+                            catch (error) {
+                                active.delete(scope);
+                                reject(String(error));
+                                return;
+                            }
+                            send({ type: "admitted", requestId: data.requestId, id: entry.id });
+                            publish(scope, entry, true);
+                            const progress = (stage) => {
+                                if (!entry.stages.includes(stage) && entry.stages.length < 16)
+                                    entry.stages.push(stage);
+                                publish(scope, entry, false);
+                            };
+                            const task = (async () => {
+                                try {
+                                    host.lifetimeSignal.throwIfAborted();
+                                    const source = await events.connect({ ...selection, sessionId: data.sourceSessionId });
+                                    let sourceText;
+                                    try {
+                                        sourceText = await collectSourceReply(source, entry.id, host.lifetimeSignal, progress);
+                                    }
+                                    finally {
+                                        source.close();
+                                    }
+                                    progress("Source reply read without changing source");
+                                    const createPirate = async () => {
+                                        ({ sessionId: entry.sessionId } = await sessions.create(selection));
+                                        currentSessions.set(scope, entry.sessionId);
+                                        // Persist identity before any potentially ambiguous send.
+                                        await store.save(scope, entry);
+                                        return events.connect({ ...selection, sessionId: entry.sessionId });
+                                    };
+                                    const previousSessionId = entry.sessionId;
+                                    const connection = previousSessionId
+                                        ? await events.connect({ ...selection, sessionId: previousSessionId }).catch((error) => {
+                                            // Only a definitive rejection before sending permits automatic replacement.
+                                            if (error instanceof Error && error.message === "Selected session is not hosted in this workspace on this machine")
+                                                return createPirate();
+                                            throw error;
+                                        })
+                                        : await createPirate();
+                                    progress("Pirate conversation selected");
+                                    try {
+                                        entry.text = await collectReply(connection, entry.id, sourceText, host.lifetimeSignal, progress);
+                                    }
+                                    finally {
+                                        connection.close();
+                                    }
+                                    entry.status = "completed";
+                                }
+                                catch (error) {
+                                    entry.status = "failed";
+                                    entry.failureCode ??= "request-failed";
+                                    entry.text = `Captain could not finish this request. Inspect the session before retrying; nothing was resent automatically.\n${error instanceof Error ? error.message : String(error)}`.slice(0, 4000);
+                                    progress("Backend recorded failure (not success)");
+                                }
+                                let saved = false;
+                                try {
+                                    if (entry.status === "completed")
+                                        entry.stages.push("Backend saved completed roundtrip");
+                                    await store.save(scope, entry);
+                                    saved = true;
+                                }
+                                catch (error) {
+                                    entry.status = "failed";
+                                    entry.failureCode = "request-failed";
+                                    entry.stages = entry.stages.filter((stage) => stage !== "Backend saved completed roundtrip");
+                                    entry.text = `Could not save Captain's Log: ${String(error)}. Inspect session ${entry.sessionId}.`.slice(0, 4000);
+                                    unsaved.set(entry.id, { ...entry });
+                                    host.logger.error(entry.text);
+                                }
+                                finally {
+                                    active.delete(scope);
+                                    publish(scope, entry, saved);
+                                }
+                            })();
+                            tasks.add(task);
+                            void task.finally(() => { tasks.delete(task); });
+                        },
+                    };
+                },
+            },
+            async dispose() {
+                await Promise.all(tasks);
+                for (const cleanup of channelCleanups)
+                    cleanup();
+                active.clear();
+                unsaved.clear();
+                currentSessions.clear();
+            },
+        };
+    },
+};
+export default plugin;