@jmfederico/pi-web 1.202608.2 → 1.202609.1

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 "@jmfederico/pi-web/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;

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

@@ -0,0 +1,75 @@
+// Generated from pi-packages/captains-log/src/store.ts. Do not edit directly.
+import { createHash, randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { lstat, mkdir, open, readdir, rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { isLogEntry } from "./browser/protocol.js";
+/** Only host-resolved ids enter the scope hash; peer input is never a filesystem path. */
+export function logScope(projectId, workspaceId) {
+    return createHash("sha256").update(JSON.stringify([projectId, workspaceId])).digest("hex");
+}
+export class LogStore {
+    dataDirectory;
+    constructor(dataDirectory) {
+        this.dataDirectory = dataDirectory;
+    }
+    async directory(scope) {
+        if (!/^[a-f0-9]{64}$/.test(scope))
+            throw new Error("Invalid captain scope");
+        const directory = join(this.dataDirectory, scope);
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        if (!(await lstat(directory)).isDirectory())
+            throw new Error("LogEntry directory must not be a symlink");
+        return directory;
+    }
+    async save(scope, captain) {
+        if (!isLogEntry(captain))
+            throw new Error("Invalid captain record");
+        const directory = await this.directory(scope);
+        const temporary = join(directory, `.${randomUUID()}.tmp`);
+        try {
+            const file = await open(temporary, "wx", 0o600);
+            try {
+                await file.writeFile(JSON.stringify(captain));
+                await file.sync();
+            }
+            finally {
+                await file.close();
+            }
+            await rename(temporary, join(directory, `${captain.id}.json`));
+        }
+        finally {
+            await rm(temporary, { force: true });
+        }
+    }
+    async read(scope, id) {
+        if (typeof id !== "string" || !/^[a-f0-9-]{36}$/.test(id))
+            throw new Error("Invalid captain id");
+        const path = join(await this.directory(scope), `${id}.json`);
+        // O_NOFOLLOW is not enforced on Windows; reject existing links there too.
+        if (!(await lstat(path)).isFile())
+            throw new Error("Invalid captain file");
+        const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+            const stat = await file.stat();
+            if (!stat.isFile() || stat.size > 300_000)
+                throw new Error("Invalid captain file");
+            const value = JSON.parse(await file.readFile("utf8"));
+            if (!isLogEntry(value) || value.id !== id)
+                throw new Error("Invalid saved captain");
+            return value;
+        }
+        finally {
+            await file.close();
+        }
+    }
+    async list(scope) {
+        const names = await readdir(await this.directory(scope));
+        const captains = [];
+        for (const name of names) {
+            if (/^[a-f0-9-]{36}\.json$/.test(name))
+                captains.push(await this.read(scope, name.slice(0, -5)));
+        }
+        return captains.sort((a, b) => b.createdAt.localeCompare(a.createdAt) || b.id.localeCompare(a.id));
+    }
+}

package/dist/pi-packages/captains-log/docs/usage.md

@@ -0,0 +1,30 @@
+# Using Captain's Log
+
+Select a conversation in the current workspace, open **Captain's Log**, and click **Let the Captain tell it**. The companion reads that session's latest completed assistant reply without sending it a prompt or changing its transcript. A separate pirate conversation retells the text using your configured model. The prompt asks for a fresh, theatrical crew briefing with nautical metaphors and humor—not just a few pirate words. It asks the model to preserve important facts, warnings, and next steps, and keep code and commands exact.
+
+The pirate gets a short introduction on its first prompt and keeps speaking pirate. Further translations use the same conversation while it is loaded in the session daemon. If it is no longer loaded, the next translation automatically creates a new pirate conversation. There are no confirmation dialogs, workspace reviews, or plain-English mode.
+
+To keep the previous pirate's context after a daemon restart, open the most recent **Captain's Log** conversation in Sessions before translating. Once loading finishes, the plugin can reuse it; it need not remain selected. Then select the conversation whose reply you want translated. The plugin does not reopen saved sessions itself or stop/delete old sessions.
+
+## Results and connections
+
+- The translation is rendered as Markdown, including headings, lists, emphasis, links, tables, and code blocks. Embedded HTML stays literal, unsafe links are inert, and images are not loaded automatically. **Previous translations** holds earlier results; **Diagnostics** holds session/request IDs and the message trail. Both start collapsed. Existing review-era logs remain on disk but are not shown as translations.
+- The panel inherits PI WEB's workspace styles and themes. The action-palette **Open pirate translator** opens it without spending model tokens.
+- Browser requests and backend progress use a bidirectional peer channel, with no polling. Opening or reconnecting loads a snapshot. Progress is not token-by-token model streaming; the completed translation arrives when the pirate finishes.
+- Closing the panel or browser does not cancel admitted work. Reconnect to recover the result. Requests with uncertain delivery are never automatically resent. Automatic pirate creation happens only before sending a translation, when the previous pirate is confirmed unhosted—not after a timeout or arbitrary connection failure.
+
+## When a translation cannot run
+
+Select an ordinary, unarchived conversation in the same workspace and machine, not the pirate itself. Wait for it to finish responding. It needs a completed assistant reply with text; partial, aborted, failed, and tool-call-only replies are not translations. If the native companion is missing from an existing session, use `/reload` in that session and try again.
+
+Only one panel translation per workspace runs at a time. Busy pirates, direct user messages during a translation, provider errors, aborted or truncated replies, and runtime replacement are reported as failures rather than successful translations. A receipt timeout or completion timeout detaches listeners but does not stop Pi. Inspect the pirate conversation before retrying an uncertain request. Very large source replies or results are rejected rather than silently truncated; see Diagnostics for the reason.
+
+Translations and metadata are stored under the host-provided plugin data directory, scoped to the project/workspace. Pi owns the conversation transcripts. Interrupted records remain visible; there is no durable job resumption or automatic retention policy. The source text is sent to the pirate's model provider. This is trusted agent code, not a tool sandbox.
+
+## Installation and activation
+
+Install from **Settings → Pi packages → Available packages** on the target machine, then explicitly enable **Captain's Log** in **Settings → PI WEB plugins**. The package ships compiled. Manual installation can use `pi install /absolute/path/to/dist/pi-packages/captains-log` with the target machine's Pi profile.
+
+Restart the target session daemon manually when safe, **from outside its hosted sessions**, then reload the browser. A web/API restart alone cannot activate the backend. Existing sessions need `/reload` to load an updated native companion. Project-scoped packages require normal project trust.
+
+Disabling the PI WEB plugin controls its panel/backend, not its native extension. Remove the Pi package to remove both resource declarations; saved conversations and plugin data are retained. The older Workspace Reviews example has a separate plugin ID and must be disabled or removed separately.

package/dist/pi-packages/captains-log/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@jmfederico/pi-captains-log",
+  "version": "0.1.0",
+  "description": "Opt-in Captain's Log: translate the selected session's last reply into pirate through a native Pi companion and PI WEB panel",
+  "private": true,
+  "type": "module",
+  "keywords": ["pi-package"],
+  "files": ["dist", "src", "docs", "test", "tsconfig.json", "vite.config.mjs"],
+  "scripts": { "build": "tsc -p tsconfig.json && vite build", "test": "node --test test/*.test.mjs" },
+  "dependencies": {
+    "marked": "^18.0.6"
+  },
+  "devDependencies": {
+    "@jmfederico/pi-web": "^1.202609.1",
+    "@earendil-works/pi-coding-agent": "^0.87.0",
+    "@types/node": "^24.13.3",
+    "typescript": "^6.0.3",
+    "vite": "^8.1.4"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@jmfederico/pi-web": "^1.202609.1"
+  },
+  "pi": { "extensions": ["./dist/companion.js"] },
+  "piWeb": {
+    "plugins": [{
+      "id": "captains-log",
+      "defaultEnabled": false,
+      "browserRoot": "dist/browser",
+      "module": "dist/browser/index.js",
+      "serverModule": "dist/server.js",
+      "machineSpecific": true
+    }]
+  }
+}

package/dist/pi-packages/captains-log/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022", "DOM"],
+    "types": ["node"],
+    "rootDir": "src",
+    "outDir": "dist",
+    "strict": true,
+    "exactOptionalPropertyTypes": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "forceConsistentCasingInFileNames": true,
+    "verbatimModuleSyntax": true,
+    "skipLibCheck": true,
+    "noEmitOnError": true
+  },
+  "include": ["src/**/*.ts"]
+}

package/dist/pi-packages/captains-log/vite.config.mjs

@@ -0,0 +1,28 @@
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vite";
+
+const packageDir = fileURLToPath(new URL(".", import.meta.url));
+
+export default defineConfig({
+  root: packageDir,
+  base: "./",
+  publicDir: false,
+  build: {
+    outDir: "dist/browser",
+    // Retain the transpiled filenames for existing package/install consumers.
+    emptyOutDir: false,
+    copyPublicDir: false,
+    target: "es2022",
+    sourcemap: false,
+    rollupOptions: {
+      input: fileURLToPath(new URL("src/browser/index.ts", import.meta.url)),
+      preserveEntrySignatures: "strict",
+      output: {
+        format: "es",
+        entryFileNames: "index.js",
+        chunkFileNames: "assets/[name]-[hash].js",
+        assetFileNames: "assets/[name]-[hash][extname]",
+      },
+    },
+  },
+});

package/dist/pi-packages/relays/package.json

@@ -2,7 +2,7 @@
   "name": "@jmfederico/pi-relay",
   "version": "0.1.0",
   "private": true,
-  "description": "Generic Relay method: /relay and /relay-worktree prompts and a relay skill for chaining independent pi sessions.",
+  "description": "Tool-agnostic Relay method, opinionated Relay Runner profile, and human-gated preparation prompts for independent Pi session chains.",
   "piWeb": {
     "plugins": [
       { "id": "relays", "browserRoot": ".", "module": "pi-web-plugin.js" }

package/dist/pi-packages/relays/pi-web-plugin.js

@@ -2,7 +2,7 @@
 import { RELAYS_ROOT } from "./relayDiscovery.js";
 import { defineRelaysPanelElement } from "./relaysPanelElement.js";
 const plugin = {
-    apiVersion: 2,
+    apiVersion: 4,
     name: "Relays",
     activate: ({ runtimePluginId, html, svg }) => {
         defineRelaysPanelElement();