mockpit 1.0.0 → 1.1.0

package/README.md

@@ -155,7 +155,7 @@ and `mockpit watch` (one line per Send, for a background monitor).
   list (an entry that is only `{id}` keeps that surface), or `parts` to replace
   just the marked elements.
 - **`feedback` returns at once** with what the user sent since the agent last
-  heard, plus `pending`: whether the viewer is open and how far the user's
+  heard, plus `pending`: whether each mock is open in the viewer and how far the user's
   draft has got (`2 of 3 answered`). Every write returns `feedback` too, and
   each Send is delivered exactly once across all of them.
 - **Asks are nudged.** A publish that leaves several variants with no ask
@@ -185,6 +185,13 @@ It runs locally as a small Node server (SQLite at `~/.mockpit/mockpit.db`), or o
 Cloudflare Workers when your agent and browser are on different machines. See
 **[docs/deploying.md](docs/deploying.md)**.
 
+The server keeps an event log, one JSON line per agent call, viewer write and
+live-feed connection (ids and shapes, never content), at
+`~/.mockpit/events.jsonl` next to the database. It rolls over at 10 MB. Set
+`MOCKPIT_LOG` to another path, or to `off` to disable it; on Workers it goes to
+Workers Logs. `node scripts/inspect.ts` in a checkout reads it alongside the
+database and Claude Code transcripts.
+
 The server app is importable from `mockpit/server` (`createApp`, `SqlStore`,
 `createSqliteStorage`). The embeddable viewer engine (`mockpit/viewer-embed`,
 `mountViewer`) is gone: the viewer is self-hosted only.

package/bin/mockpit.js

@@ -19,6 +19,12 @@ const BASE = (process.env.MOCKPIT_URL ?? "http://localhost:8228").replace(/\/$/,
 const TOKEN = process.env.MOCKPIT_TOKEN;
 const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
 const PKG_VERSION = JSON.parse(readFileSync(join(ROOT, "package.json"), "utf8")).version;
+// Every request names this client and its version, so the server's event log
+// can tell the CLI from MCP and spot one older than the server.
+const HEADERS = {
+  "x-mockpit-client": `cli/${PKG_VERSION}`,
+  ...(TOKEN ? { authorization: `Bearer ${TOKEN}` } : {}),
+};
 
 const HELP = `mockpit — a live visual surface for terminal coding agents
 
@@ -118,6 +124,7 @@ environment:
   MOCKPIT_URL      server base URL (default http://localhost:8228)
   MOCKPIT_TOKEN    bearer token for a deployed instance
   MOCKPIT_HOST     address serve binds to (default: every interface)
+  MOCKPIT_LOG      serve's event log file, or "off" (default ~/.mockpit/events.jsonl)
   MOCKPIT_SESSION  fixed session id (overrides auto-detection)
   MOCKPIT_AGENT    agent name used when creating sessions
 `;
@@ -241,7 +248,7 @@ async function api(path, init = {}, { report, fix } = {}) {
       ...init,
       headers: {
         "content-type": "application/json",
-        ...(TOKEN ? { authorization: `Bearer ${TOKEN}` } : {}),
+        ...HEADERS,
         ...init.headers,
       },
     });
@@ -364,7 +371,7 @@ async function resolveSession(flags, { create = false } = {}) {
   const state = readState();
   if (state.session && !flags["new-session"]) {
     const ok = await fetch(`${BASE}/api/sessions/${state.session}`, {
-      headers: TOKEN ? { authorization: `Bearer ${TOKEN}` } : {},
+      headers: HEADERS,
     }).then(
       (r) => r.ok,
       () => false,
@@ -394,7 +401,7 @@ async function resolveSession(flags, { create = false } = {}) {
 async function resolveSessionByCwd(cwd = process.cwd()) {
   try {
     const res = await fetch(`${BASE}/api/sessions`, {
-      headers: TOKEN ? { authorization: `Bearer ${TOKEN}` } : {},
+      headers: HEADERS,
     });
     if (!res.ok) return null;
     const sessions = await res.json();
@@ -533,7 +540,7 @@ async function uploadBytes(bytes, { filename, contentType, session, kind } = {})
       method: "POST",
       headers: {
         "content-type": contentType ?? "application/octet-stream",
-        ...(TOKEN ? { authorization: `Bearer ${TOKEN}` } : {}),
+        ...HEADERS,
       },
       body: bytes,
     });
@@ -818,19 +825,17 @@ function printFeedback(feedback) {
   if (feedback?.length) console.log(`feedback: ${JSON.stringify(feedback)}`);
 }
 
-// What the user is doing right now. viewerOpen is workspace-wide, so it is
-// said once rather than per mock.
+// What the user is doing right now, per mock.
 function pendingLines(pending) {
-  const rows = pending ?? [];
-  const lines = rows
-    .filter((p) => p.draft)
-    .map(
-      (p) =>
-        `pending: ${p.mock} — the user is answering (${p.draft.answered} of ${p.draft.of} answered, ${p.draft.comments} comment${p.draft.comments === 1 ? "" : "s"})`,
-    );
-  if (lines.length === 0 && rows.some((p) => p.viewerOpen))
-    lines.push("pending: the viewer is open");
-  return lines;
+  return (pending ?? []).flatMap((p) =>
+    p.draft
+      ? [
+          `pending: ${p.mock} — the user is answering (${p.draft.answered} of ${p.draft.of} answered, ${p.draft.comments} comment${p.draft.comments === 1 ? "" : "s"})`,
+        ]
+      : p.viewerOpen
+        ? [`pending: ${p.mock} — open in the viewer`]
+        : [],
+  );
 }
 
 function parsePublishFlags() {
@@ -1020,7 +1025,7 @@ async function apiSoft(path) {
   let res;
   try {
     res = await fetch(`${BASE}${path}`, {
-      headers: TOKEN ? { authorization: `Bearer ${TOKEN}` } : {},
+      headers: HEADERS,
     });
   } catch {
     die(`cannot reach mockpit at ${BASE}`, "mockpit serve");
@@ -1543,7 +1548,7 @@ const commands = {
       try {
         const res = await fetch(
           `${BASE}/api/comments${query({ session, author: "user", after: firstAfter, wait: 60 })}`,
-          { headers: TOKEN ? { authorization: `Bearer ${TOKEN}` } : {} },
+          { headers: HEADERS },
         );
         if (!res.ok) {
           await sleep(2000);

package/dist/mcp/server.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import { execFileSync } from "node:child_process";
 import { readFileSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
@@ -12,8 +14,28 @@ const TOKEN = process.env.MOCKPIT_TOKEN;
 const AGENT = process.env.MOCKPIT_AGENT ?? "claude-code";
 // "code" serves the codemode catalog: one `run` tool instead of the mock tools.
 const CODE_MODE = process.env.MOCKPIT_MCP_MODE === "code";
+// Names this client in the server's event log; the version is how a stdio
+// server left running across an upgrade shows up there.
+const CLIENT = `mcp-stdio/${packageVersion()}`;
+// Source runs as mcp/server.ts, the published copy as dist/mcp/server.js.
+function packageVersion() {
+    for (const rel of ["../package.json", "../../package.json"]) {
+        try {
+            const pkg = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), rel), "utf8"));
+            if (pkg.name === "mockpit")
+                return String(pkg.version);
+        }
+        catch {
+            // Not at this depth.
+        }
+    }
+    return "unknown";
+}
 async function api(path, init = {}) {
-    const headers = { "content-type": "application/json" };
+    const headers = {
+        "content-type": "application/json",
+        "x-mockpit-client": CLIENT,
+    };
     if (TOKEN)
         headers.authorization = `Bearer ${TOKEN}`;
     let res;

package/dist/server/app.d.ts

@@ -2,6 +2,7 @@ import { Hono } from "hono";
 import { type FeedEvent } from "./events.ts";
 import { type GuideTopic } from "./designGuide.ts";
 import { type Executor, type RunLimits } from "./run.ts";
+import { type LogSink } from "./eventLog.ts";
 import { type Store } from "./types.ts";
 export type { FeedEvent } from "./events.ts";
 export type { FeedbackBatch } from "./feedbackBatch.ts";
@@ -25,6 +26,7 @@ export interface AppOptions {
     maxHoldConnections?: number;
     executor?: Executor;
     runLimits?: Partial<RunLimits>;
+    log?: LogSink;
 }
 export interface LatestRelease {
     version: string;
@@ -50,4 +52,4 @@ export interface FlowContext {
     request?: Request;
     signal?: AbortSignal;
 }
-export declare function createApp({ store, viewerHtml, setupText, topics, authenticate, authToken, basePath, publicRead, screenshots, version, upgradeCommand, fetchLatestRelease, onEvent, maxHoldConnections, executor, runLimits, }: AppOptions): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export declare function createApp({ store, viewerHtml, setupText, topics, authenticate, authToken, basePath, publicRead, screenshots, version, upgradeCommand, fetchLatestRelease, onEvent, maxHoldConnections, executor, runLimits, log, }: AppOptions): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;

package/dist/server/app.js

@@ -16,6 +16,7 @@ import { addHook, addSubscription, isPushSubscription, listHooks, notify, remove
 import { expandSlots, parseSlotTags } from "./slots.js";
 import { registerMcp } from "./mcpHttp.js";
 import { createRunFlow, DEFAULT_RUN_LIMITS } from "./run.js";
+import { logMiddleware, writeLog } from "./eventLog.js";
 import { RUN_API } from "./runApi.js";
 import { escapeHtml, renderHtmlPage, renderMermaidPage, renderSandboxedPart, STATIC_ASSET_PREFIX, staticAsset, } from "./surfacePage.js";
 import { DEFAULT_MODE, DEFAULT_THEME_ID, isMode, themeById } from "./themes.js";
@@ -166,7 +167,7 @@ const MAX_ASKS = 20;
 const MAX_OPTIONS = 20;
 const MAX_DRAFT_COMMENTS = 50;
 const titleFromSlug = (slug) => slug.replace(/-/g, " ").replace(/^./, (ch) => ch.toUpperCase());
-export function createApp({ store, viewerHtml, setupText, topics = {}, authenticate, authToken, basePath, publicRead, screenshots, version, upgradeCommand, fetchLatestRelease, onEvent, maxHoldConnections = DEFAULT_MAX_HOLD_CONNECTIONS, executor, runLimits, }) {
+export function createApp({ store, viewerHtml, setupText, topics = {}, authenticate, authToken, basePath, publicRead, screenshots, version, upgradeCommand, fetchLatestRelease, onEvent, maxHoldConnections = DEFAULT_MAX_HOLD_CONNECTIONS, executor, runLimits, log, }) {
     const app = new Hono();
     // The scripts topic carries the run API from runApi.ts, its one source.
     if (topics.scripts)
@@ -188,6 +189,8 @@ export function createApp({ store, viewerHtml, setupText, topics = {}, authentic
         c.header("Referrer-Policy", "no-referrer");
         return next();
     });
+    if (log)
+        app.use("*", logMiddleware(log));
     const bus = new EventBus();
     if (onEvent) {
         bus.subscribe((event) => {
@@ -203,9 +206,10 @@ export function createApp({ store, viewerHtml, setupText, topics = {}, authentic
     // Each holder increments on entry and releases exactly once via a guarded
     // release() wired to every exit (stream abort, request abort, normal return).
     let holdConnections = 0;
-    // Only the viewer holds /api/events (watch long-polls), so an attached SSE
-    // client means someone has the workspace open.
-    let viewerClients = 0;
+    // Only the viewer holds /api/events (watch long-polls). Each tab names the
+    // mock it has on screen (`?viewing=`), so pending.viewerOpen is per mock: a
+    // tab on Home or on another mock doesn't read as "looking at this one".
+    const viewing = new Map();
     const acquireHold = () => {
         if (holdConnections >= maxHoldConnections)
             return false;
@@ -1960,7 +1964,7 @@ export function createApp({ store, viewerHtml, setupText, topics = {}, authentic
     // tells the agent something ("2 of 3 answered", or nobody is looking).
     const pendingOf = (mock, posts) => ({
         mock: mock.slug,
-        viewerOpen: viewerClients > 0,
+        viewerOpen: viewing.has(mock.id),
         draft: mock.draft
             ? {
                 answered: Object.keys(mock.draft.answers).length,
@@ -2986,12 +2990,30 @@ export function createApp({ store, viewerHtml, setupText, topics = {}, authentic
         }
         if (!acquireHold())
             return c.json({ error: "too many concurrent connections" }, 503);
-        viewerClients++;
+        const openedAt = Date.now();
+        const viewingId = str(c.req.query("viewing"), MAX_TITLE);
+        if (viewingId)
+            viewing.set(viewingId, (viewing.get(viewingId) ?? 0) + 1);
         let attached = true;
         const releaseHold = makeRelease();
         const release = () => {
-            if (attached)
-                viewerClients--;
+            if (attached) {
+                if (viewingId) {
+                    const left = (viewing.get(viewingId) ?? 1) - 1;
+                    if (left > 0)
+                        viewing.set(viewingId, left);
+                    else
+                        viewing.delete(viewingId);
+                }
+                writeLog(log, {
+                    t: new Date().toISOString(),
+                    op: "sse close",
+                    client: "viewer",
+                    status: 200,
+                    ms: Date.now() - openedAt,
+                    ...(viewingId ? { viewing: viewingId } : {}),
+                });
+            }
             attached = false;
             releaseHold();
         };

package/dist/server/eventLog.d.ts

@@ -0,0 +1,27 @@
+import type { MiddlewareHandler } from "hono";
+export interface LogEntry {
+    t: string;
+    op: string;
+    client: string;
+    status: number;
+    ms: number;
+    session?: string;
+    project?: string;
+    mock?: string;
+    state?: string | null;
+    variant?: string;
+    version?: number;
+    delivered?: number[];
+    pending?: string[];
+    nudges?: number;
+    reply?: number;
+    viewing?: string;
+    key?: string;
+    error?: string;
+}
+export type LogSink = (entry: LogEntry) => void;
+export declare function clientOf(header: string | undefined, viewer: boolean, mcp: boolean): string;
+export declare function fromRequest(query: URLSearchParams, body: unknown, pathMock: string | undefined): Partial<LogEntry>;
+export declare function fromResponse(body: unknown): Partial<LogEntry>;
+export declare function writeLog(sink: LogSink | undefined, entry: LogEntry): void;
+export declare function logMiddleware(sink: LogSink): MiddlewareHandler;

package/dist/server/eventLog.js

@@ -0,0 +1,187 @@
+// The event log: one entry per call that moves the loop (agent writes and
+// reads, viewer writes, the viewer's live feed), so a session can be diagnosed
+// after the fact — which client sent what, which reply seqs it was handed, what
+// the agent was told was pending. Shapes and ids only, never html or comment
+// text: the store already holds the content under the same ids, and a log that
+// copied it would be a second, unbounded store. `scripts/inspect.ts` reads it.
+const MAX_ERROR = 300;
+const CLIENT = /^[\w.@/-]{1,64}$/;
+export function clientOf(header, viewer, mcp) {
+    if (header && CLIENT.test(header))
+        return header;
+    if (viewer)
+        return "viewer";
+    return mcp ? "mcp-http" : "http";
+}
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const text = (v) => typeof v === "string" && v ? v.slice(0, 200) : undefined;
+// What the request itself names, for calls whose response doesn't (errors,
+// feedback reads).
+export function fromRequest(query, body, pathMock) {
+    const b = isObj(body) ? body : {};
+    return prune({
+        session: text(query.get("session")) ?? text(b.session),
+        project: text(query.get("project")) ?? text(b.project),
+        mock: pathMock ?? text(b.mock),
+        variant: text(b.variant),
+        viewing: text(query.get("viewing")),
+    });
+}
+// What a flow's response body says about the call.
+export function fromResponse(body) {
+    if (!isObj(body))
+        return {};
+    const mock = isObj(body.mock) ? body.mock : undefined;
+    const post = isObj(body.post) ? body.post : undefined;
+    // POST /api/sessions answers with the bare session (201 new, 200 reclaimed by key).
+    const session = typeof body.agentSeq === "number" ? body : undefined;
+    const delivered = deliveredSeqs(body.feedback);
+    const pending = pendingLines(body.pending);
+    return prune({
+        session: text(body.sessionId) ?? text(post?.sessionId) ?? text(session?.id),
+        key: text(session?.key),
+        project: text(mock?.project) ?? text(body.project) ?? text(session?.project),
+        mock: text(mock?.slug) ??
+            text(body.slug) ??
+            (typeof body.mock === "string" ? text(body.mock) : undefined),
+        state: post ? (post.state ?? null) : undefined,
+        variant: text(post?.variant),
+        version: typeof post?.version === "number" ? post.version : undefined,
+        delivered: delivered.length ? delivered : undefined,
+        pending: pending.length ? pending : undefined,
+        nudges: Array.isArray(body.nudges) && body.nudges.length ? body.nudges.length : undefined,
+        reply: isObj(body.reply) && typeof body.reply.seq === "number" ? body.reply.seq : undefined,
+        error: typeof body.error === "string" ? body.error.slice(0, MAX_ERROR) : undefined,
+    });
+}
+function deliveredSeqs(feedback) {
+    if (!Array.isArray(feedback))
+        return [];
+    const seqs = [];
+    for (const batch of feedback) {
+        if (!isObj(batch))
+            continue;
+        if (isObj(batch.reply) && typeof batch.reply.seq === "number")
+            seqs.push(batch.reply.seq);
+        for (const c of Array.isArray(batch.comments) ? batch.comments : []) {
+            if (isObj(c) && typeof c.seq === "number")
+                seqs.push(c.seq);
+        }
+    }
+    return seqs.sort((a, b) => a - b);
+}
+function pendingLines(pending) {
+    const rows = Array.isArray(pending) ? pending : isObj(pending) ? [pending] : [];
+    return rows.flatMap((p) => {
+        if (!isObj(p) || typeof p.mock !== "string")
+            return [];
+        if (isObj(p.draft))
+            return [`${p.mock} ${p.draft.answered}/${p.draft.of} answered`];
+        return p.viewerOpen ? [`${p.mock} open`] : [];
+    });
+}
+function prune(entry) {
+    for (const k of Object.keys(entry))
+        if (entry[k] === undefined)
+            delete entry[k];
+    return entry;
+}
+// A sink that throws must never fail the request it describes.
+export function writeLog(sink, entry) {
+    if (!sink)
+        return;
+    try {
+        sink(entry);
+    }
+    catch {
+        // The log is diagnostics; losing an entry beats losing the call.
+    }
+}
+// The viewer's reads (it refetches on every feed event) would drown the agent's
+// calls, so only its writes and its feed connection are logged.
+function loggable(c, viewer) {
+    const path = c.req.path;
+    if (path === "/mcp")
+        return c.req.method === "POST";
+    if (!path.startsWith("/api/"))
+        return false;
+    return path === "/api/events" || c.req.method !== "GET" || !viewer;
+}
+const isJson = (type) => !!type?.includes("application/json");
+export function logMiddleware(sink) {
+    return async (c, next) => {
+        const start = Date.now();
+        await next();
+        const viewer = c.req.header("sec-fetch-site") === "same-origin";
+        if (!loggable(c, viewer))
+            return;
+        try {
+            const url = new URL(c.req.url);
+            // Handlers already parsed the body; Hono hands back its cached copy.
+            const reqBody = isJson(c.req.header("content-type"))
+                ? await c.req.json().catch(() => undefined)
+                : undefined;
+            // Never clone a non-JSON body: a clone of the SSE stream is a tee branch
+            // nobody reads, which buffers every event for the connection's life.
+            const resBody = isJson(c.res.headers.get("content-type"))
+                ? await c.res
+                    .clone()
+                    .json()
+                    .catch(() => undefined)
+                : undefined;
+            const mcp = c.req.path === "/mcp";
+            const entry = {
+                t: new Date().toISOString(),
+                op: mcp ? mcpOp(reqBody) : `${c.req.method} ${c.req.path}`,
+                client: clientOf(c.req.header("x-mockpit-client"), viewer, mcp),
+                status: c.res.status,
+                ms: Date.now() - start,
+            };
+            if (mcp) {
+                const call = isObj(reqBody) && isObj(reqBody.params) ? reqBody.params : {};
+                Object.assign(entry, fromRequest(url.searchParams, call.arguments, undefined));
+                Object.assign(entry, fromMcpResult(resBody));
+            }
+            else {
+                const pathMock = /^\/api\/mocks\/([^/]+)/.exec(c.req.path)?.[1];
+                Object.assign(entry, fromRequest(url.searchParams, reqBody, pathMock));
+                Object.assign(entry, fromResponse(resBody));
+            }
+            writeLog(sink, entry);
+        }
+        catch {
+            // Same as writeLog: diagnostics never fail the call.
+        }
+    };
+}
+function mcpOp(body) {
+    if (!isObj(body))
+        return "mcp";
+    if (body.method === "tools/call" && isObj(body.params)) {
+        return `mcp ${text(body.params.name) ?? "?"}`;
+    }
+    return `mcp ${text(body.method) ?? "?"}`;
+}
+// A tool result carries the flow's JSON body: structured where the tool
+// declares an output schema, else as its text content.
+function fromMcpResult(body) {
+    if (!isObj(body))
+        return {};
+    if (isObj(body.error))
+        return { error: String(body.error.message).slice(0, MAX_ERROR) };
+    const result = isObj(body.result) ? body.result : {};
+    if (isObj(result.structuredContent))
+        return fromResponse(result.structuredContent);
+    const first = Array.isArray(result.content) ? result.content[0] : undefined;
+    const raw = isObj(first) && typeof first.text === "string" ? first.text : undefined;
+    if (raw === undefined)
+        return {};
+    if (result.isError)
+        return { error: raw.slice(0, MAX_ERROR) };
+    try {
+        return fromResponse(JSON.parse(raw));
+    }
+    catch {
+        return {};
+    }
+}

package/dist/server/index.js

@@ -6,6 +6,7 @@ import { fileURLToPath } from "node:url";
 import { createApp } from "./app.js";
 import { createNodeExecutor } from "./codeRunner.js";
 import { GUIDE_TOPICS } from "./designGuide.js";
+import { createFileLog } from "./logFile.js";
 import { SqlStore } from "./sqlStore.js";
 import { createSqliteStorage } from "./sqliteStorage.js";
 // Source layout puts this file at server/index.ts; the published package runs
@@ -33,6 +34,16 @@ const publicRead = pr === "session" || pr === "full" ? pr : undefined;
 const dbPath = process.env.MOCKPIT_DB ?? join(homedir(), ".mockpit", "mockpit.db");
 const store = new SqlStore(createSqliteStorage(dbPath));
 console.log(`mockpit store: SQLite at ${dbPath}`);
+// The event log is on by default, next to the database, so a session can be
+// diagnosed after the fact without having planned to (`scripts/inspect.ts`).
+// MOCKPIT_LOG names another file; "off" disables it. An in-memory database
+// gets none unless asked: it is a throwaway run.
+const logSetting = process.env.MOCKPIT_LOG;
+const logPath = logSetting === "off"
+    ? undefined
+    : logSetting || (dbPath === ":memory:" ? undefined : join(dirname(dbPath), "events.jsonl"));
+if (logPath)
+    console.log(`mockpit event log: ${logPath}`);
 const app = createApp({
     store,
     viewerHtml,
@@ -46,6 +57,7 @@ const app = createApp({
     upgradeCommand: "npm install -g mockpit",
     // `run` scripts execute in QuickJS inside a worker thread per run.
     executor: createNodeExecutor(),
+    log: logPath ? createFileLog(logPath) : undefined,
 });
 const port = Number(process.env.PORT ?? 8228);
 // MOCKPIT_HOST (or `serve --host`) restricts the listener to one address.

package/dist/server/logFile.d.ts

@@ -0,0 +1,2 @@
+import type { LogSink } from "./eventLog.ts";
+export declare function createFileLog(path: string, maxBytes?: number): LogSink;

package/dist/server/logFile.js

@@ -0,0 +1,27 @@
+import { appendFileSync, mkdirSync, renameSync, statSync } from "node:fs";
+import { dirname } from "node:path";
+// One file plus one rotated predecessor caps the log at twice this, so leaving
+// it on by default costs a bounded slice of disk.
+const DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
+// Appends JSONL to `path`, rolling it to `<path>.1` past `maxBytes`. Writes are
+// synchronous so lines never interleave and a crash loses nothing already
+// answered; the loop's call rate makes that cost negligible.
+export function createFileLog(path, maxBytes = DEFAULT_MAX_BYTES) {
+    mkdirSync(dirname(path), { recursive: true });
+    let size = 0;
+    try {
+        size = statSync(path).size;
+    }
+    catch {
+        // No file yet.
+    }
+    return (entry) => {
+        const line = `${JSON.stringify(entry)}\n`;
+        if (size > 0 && size + line.length > maxBytes) {
+            renameSync(path, `${path}.1`);
+            size = 0;
+        }
+        appendFileSync(path, line);
+        size += Buffer.byteLength(line);
+    };
+}

package/extensions/mockpit.js

@@ -1,4 +1,5 @@
 import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { basename, resolve } from "node:path";
 
@@ -127,8 +128,19 @@ function resolveProjectName(cwd) {
   );
 }
 
+// Names this client in the server's event log, with the version that would
+// show it running behind the server.
+const CLIENT = `pi/${(() => {
+  try {
+    return JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+  } catch {
+    return "unknown";
+  }
+})()}`;
+
 function authHeaders(extra = {}) {
   return {
+    "x-mockpit-client": CLIENT,
     ...(process.env.MOCKPIT_TOKEN ? { authorization: `Bearer ${process.env.MOCKPIT_TOKEN}` } : {}),
     ...extra,
   };
@@ -234,17 +246,19 @@ function feedbackLines(feedback) {
   return lines;
 }
 
-// What the user is doing right now, so the agent can say "take your time".
-// viewerOpen is workspace-wide, so it is said once rather than per mock.
+// What the user is doing right now, per mock, so the agent can say "take your time".
 function pendingLines(pending) {
-  const rows = [pending ?? []].flat();
-  const lines = rows
-    .filter((p) => p.draft)
-    .map(
-      (p) =>
-        `- ${p.mock}: the user is answering (${p.draft.answered} of ${p.draft.of} answered, ${p.draft.comments} comments)`,
+  const lines = [pending ?? []]
+    .flat()
+    .flatMap((p) =>
+      p.draft
+        ? [
+            `- ${p.mock}: the user is answering (${p.draft.answered} of ${p.draft.of} answered, ${p.draft.comments} comments)`,
+          ]
+        : p.viewerOpen
+          ? [`- ${p.mock}: open in the viewer`]
+          : [],
     );
-  if (lines.length === 0 && rows.some((p) => p.viewerOpen)) lines.push("- the viewer is open");
   return lines.length ? ["Pending:", ...lines] : [];
 }
 

package/guide/topics/feedback.md

@@ -53,8 +53,8 @@ It returns at once:
 ```
 
 `feedback` holds one batch per mock, in delivery order. `pending` is what the
-user is doing right now, per mock: `viewerOpen` says a browser has the
-workspace open, `draft` is their unsent progress (`null` when there is none).
+user is doing right now, per mock: `viewerOpen` says a browser has that
+mock on screen, `draft` is their unsent progress (`null` when there is none).
 An empty `feedback` with a draft means "still answering": tell the user to take
 their time, don't ask again. `mockpit read` returns `pending` too, without
 taking any feedback.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mockpit",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "A design-decision loop for terminal coding agents — agents publish mocks with states and variants, ask questions and expose knobs; you answer, tune and comment, then send one reply.",
   "keywords": [
     "agent-tools",
@@ -82,7 +82,7 @@
     "lint:fix": "oxlint . --fix",
     "changeset": "changeset",
     "changeset:status": "changeset status",
-    "release:version": "changeset version",
+    "release:version": "changeset version && npm install --package-lock-only --ignore-scripts",
     "typecheck": "tsc --noEmit && tsc -p tsconfig.workers.json --noEmit && tsc -p tsconfig.viewer.json --noEmit",
     "clean:dist": "node scripts/clean-dist.ts",
     "build": "npm run clean:dist && tsc -p tsconfig.build.json && npm run build:viewer",