@pasko70/pibo 2.5.2 → 3.0.1

package/dist/core/user-settings.js

@@ -1,11 +1,13 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { piboHomePath } from "./pibo-home.js";
+import { sanitizePreviewServerSettings } from "./preview-server-settings.js";
 import { sanitizeTelemetryRetentionSettings } from "./telemetry-retention-settings.js";
 import { sanitizeTelemetryStaleThresholdSettings } from "./telemetry-staleness.js";
 export const DEFAULT_USER_TIMEZONE = "UTC";
 export const DEFAULT_WEB_ANNOTATIONS_TOGGLE_SHORTCUT = "Alt+Shift+A";
 export const DEFAULT_TRANSCRIPTION_PROVIDER_ID = "openai-chatgpt";
+export const DEFAULT_SPEECH_PROVIDER_ID = "openai-codex";
 const LEGACY_OPENAI_TRANSCRIPTION_PROVIDER_ID = "openai";
 export const DEFAULT_PIBO_USER_SETTINGS_PATH = "user-settings.json";
 export function loadPiboUserSettings() {
@@ -56,6 +58,12 @@ export function sanitizeTranscriptionSettings(value) {
             : providerId ?? DEFAULT_TRANSCRIPTION_PROVIDER_ID,
     };
 }
+export function sanitizeSpeechSettings(value) {
+    const raw = value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+    return { providerId: sanitizeTranscriptionProviderId(raw.providerId) ?? DEFAULT_SPEECH_PROVIDER_ID };
+}
 export function sanitizeTimezone(value) {
     if (typeof value !== "string")
         return undefined;
@@ -78,6 +86,8 @@ function sanitizeUserSettings(value) {
         timezone: sanitizeTimezone(raw.timezone) ?? DEFAULT_USER_TIMEZONE,
         shortcuts: sanitizeShortcutSettings(raw.shortcuts),
         transcription: sanitizeTranscriptionSettings(raw.transcription),
+        speech: sanitizeSpeechSettings(raw.speech),
+        previewServers: sanitizePreviewServerSettings(raw.previewServers),
         telemetryStaleThresholds: sanitizeTelemetryStaleThresholdSettings(raw.telemetryStaleThresholds),
         telemetryRetention: sanitizeTelemetryRetentionSettings(raw.telemetryRetention),
     };

package/dist/data/payload-store.js

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { gunzipSync, gzipSync } from "node:zlib";
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { closeSync, existsSync, fstatSync, mkdirSync, openSync, readFileSync, readSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, extname, join, resolve } from "node:path";
 import { piboHomePath } from "../core/pibo-home.js";
 const MAX_SYNC_PAYLOAD_GZIP_BYTES = 512 * 1024;
@@ -78,11 +78,67 @@ export class PayloadStore {
     readPayloadJson(id) {
         return JSON.parse(this.readPayloadText(id));
     }
+    readPayloadBytesBounded(id, maxBytes) {
+        if (!Number.isSafeInteger(maxBytes) || maxBytes < 1)
+            throw new RangeError("maxBytes must be a positive safe integer");
+        const payload = this.getPayload(id);
+        if (!payload)
+            throw new Error(`Unknown payload \"${id}\"`);
+        if (!payload.storagePath)
+            throw new Error(`Payload \"${id}\" has no storage path`);
+        if (payload.byteSize > maxBytes)
+            throw new RangeError(`Payload \"${id}\" exceeds the ${maxBytes}-byte read limit`);
+        const absolutePath = this.rootDir === ":memory:" ? payload.storagePath : join(this.rootDir, payload.storagePath);
+        const storedBytes = readFileBounded(absolutePath, maxBytes + 64 * 1024);
+        let bytes;
+        if (payload.encoding === "gzip")
+            bytes = gunzipSync(storedBytes, { maxOutputLength: maxBytes });
+        else if (payload.encoding === "identity")
+            bytes = storedBytes;
+        else
+            throw new Error(`Unsupported payload encoding \"${payload.encoding}\"`);
+        if (bytes.byteLength !== payload.byteSize)
+            throw new Error(`Payload \"${id}\" byte length does not match its metadata`);
+        const sha256 = createHash("sha256").update(bytes).digest("hex");
+        if (sha256 !== payload.sha256)
+            throw new Error(`Payload \"${id}\" checksum does not match its metadata`);
+        return bytes;
+    }
+    readPayloadJsonBounded(id, maxBytes) {
+        return JSON.parse(Buffer.from(this.readPayloadBytesBounded(id, maxBytes)).toString("utf8"));
+    }
     findBySha256(sha256) {
         const row = this.db.prepare("SELECT * FROM payloads WHERE sha256 = ?").get(sha256);
         return row ? payloadFromRow(row) : undefined;
     }
 }
+function readFileBounded(path, maxBytes) {
+    const descriptor = openSync(path, "r");
+    try {
+        const stats = fstatSync(descriptor);
+        if (!stats.isFile())
+            throw new Error(`Payload path is not a file: ${path}`);
+        if (stats.size > maxBytes)
+            throw new RangeError(`Stored payload exceeds the ${maxBytes}-byte read limit`);
+        const bytes = Buffer.alloc(stats.size);
+        let offset = 0;
+        while (offset < bytes.byteLength) {
+            const read = readSync(descriptor, bytes, offset, bytes.byteLength - offset, offset);
+            if (read === 0)
+                break;
+            offset += read;
+        }
+        if (offset !== bytes.byteLength)
+            throw new Error(`Stored payload changed while it was being read: ${path}`);
+        const extra = Buffer.alloc(1);
+        if (readSync(descriptor, extra, 0, 1, offset) !== 0)
+            throw new RangeError(`Stored payload exceeds the ${maxBytes}-byte read limit`);
+        return bytes;
+    }
+    finally {
+        closeSync(descriptor);
+    }
+}
 function defaultContentType(value) {
     if (typeof value === "string")
         return "text/plain; charset=utf-8";

package/dist/data/schema.js

@@ -1,4 +1,4 @@
-export const PIBO_DATA_SCHEMA_VERSION = 5;
+export const PIBO_DATA_SCHEMA_VERSION = 6;
 export function applyPiboDataSchema(db) {
     const previousVersion = Number(db.prepare("PRAGMA user_version").get()?.user_version ?? 0);
     const existingSessionCount = db.prepare("SELECT COUNT(*) AS count FROM sqlite_schema WHERE type = 'table' AND name = 'sessions'").get();
@@ -423,6 +423,23 @@ export function applyPiboDataSchema(db) {
 			ON event_log(session_id, session_sequence DESC, stream_id DESC);
 		CREATE INDEX IF NOT EXISTS idx_event_log_session_type_sequence_stream
 			ON event_log(session_id, type, session_sequence ASC, stream_id ASC);
+		CREATE INDEX IF NOT EXISTS idx_event_log_session_tool_event_sequence_stream
+			ON event_log(session_id, tool_call_id, event_id, session_sequence ASC, stream_id ASC)
+			WHERE tool_call_id IS NOT NULL
+				AND type IN ('tool_execution_started', 'tool_execution_updated', 'tool_execution_finished');
+		CREATE INDEX IF NOT EXISTS idx_event_log_session_tool_sequence_stream
+			ON event_log(session_id, tool_call_id, session_sequence ASC, stream_id ASC)
+			WHERE tool_call_id IS NOT NULL
+				AND type IN ('tool_execution_started', 'tool_execution_updated', 'tool_execution_finished');
+		CREATE INDEX IF NOT EXISTS idx_event_log_session_attribute_tool_event_sequence_stream
+			ON event_log(
+				session_id,
+				json_extract(attributes_json, '$.toolCallId'),
+				event_id,
+				session_sequence ASC,
+				stream_id ASC
+			)
+			WHERE type IN ('tool_execution_started', 'tool_execution_updated', 'tool_execution_finished');
 		CREATE INDEX IF NOT EXISTS idx_event_log_room_stream
 			ON event_log(room_id, stream_id);
 		CREATE INDEX IF NOT EXISTS idx_event_log_topic_stream

package/dist/debug/trace.js

@@ -46,10 +46,14 @@ export async function inspectDebugTrace(piboSessionId, stores, options = {}) {
         const productHistory = readProductHistoryEntries(chatDb, payloadStore, piboSessionId);
         let nativeHistoryEntries = [];
         let nativeHistoryInspection;
+        let nativeHistoryReconciliationProof;
         if (options.nativeHistory || (events.length === 0 && productHistory.length === 0)) {
             const native = await readDebugNativeHistory(binding, session.workspace ?? process.cwd(), adapterIssues);
             nativeHistoryEntries = native?.entries ?? [];
             nativeHistoryInspection = native?.inspection;
+            nativeHistoryReconciliationProof = native
+                ? native.reconciliationProof ?? { complete: false, entries: native.entries }
+                : undefined;
         }
         const historyEntries = nativeHistoryEntries.length ? nativeHistoryEntries : productHistory;
         const historySource = nativeHistoryEntries.length
@@ -62,6 +66,7 @@ export async function inspectDebugTrace(piboSessionId, stores, options = {}) {
             events,
             historyEntries,
             historyInspection: nativeHistoryInspection,
+            historyReconciliationProof: nativeHistoryEntries.length ? nativeHistoryReconciliationProof : undefined,
             status: sessionStatus.status,
         });
         const rows = flattenTraceNodes(view.nodes);

package/dist/gateway/client.js

@@ -4,6 +4,44 @@ import readline from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { DEFAULT_GATEWAY_HOST, DEFAULT_GATEWAY_PORT, encodeFrame, } from "./protocol.js";
 import { parsePiboThinkingLevel } from "../core/thinking.js";
+const DEFAULT_ACKNOWLEDGEMENT_TIMEOUT_MS = 5_000;
+const DEFAULT_TERMINAL_TIMEOUT_MS = 120_000;
+export class GatewayClientExpectedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GatewayClientExpectedError";
+    }
+}
+export function isGatewayClientExpectedError(error) {
+    return error instanceof GatewayClientExpectedError;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function parseGatewayClientMessage(value) {
+    const text = value.trim();
+    if (!text)
+        return { ok: false, error: "Message text is required" };
+    const command = /^\/(queue|steer)(?:\s+|$)/.exec(text);
+    if (!command)
+        return { ok: true, text };
+    const delivery = command[1];
+    const message = text.slice(command[0].length).trim();
+    return message
+        ? { ok: true, text: message, delivery }
+        : { ok: false, error: `Usage: /${delivery} <message>` };
+}
+export function createGatewayClientRequestFrame(event) {
+    const id = randomUUID();
+    return { type: "req", id, event: { ...event, id: event.id ?? id } };
+}
+export function createGatewayClientSubscriptionFrame(piboSessionId) {
+    return {
+        type: "subscribe",
+        id: randomUUID(),
+        subscription: { type: "session", piboSessionId },
+    };
+}
 function parseJsonLine(line) {
     try {
         return JSON.parse(line);
@@ -16,9 +54,22 @@ function writeFrame(socket, frame) {
     socket.write(encodeFrame(frame));
 }
 function printResponse(frame) {
-    if (frame.ok)
+    if (!frame.ok) {
+        console.error(`\nerror: ${frame.error?.message ?? "request failed"}`);
+        return;
+    }
+    if (!frame.payload || typeof frame.payload !== "object")
         return;
-    console.error(`\nerror: ${frame.error?.message ?? "request failed"}`);
+    const payload = frame.payload;
+    if (payload.type !== "message_steered" || typeof payload.activeEventId !== "string" || payload.activeEventId.length === 0)
+        return;
+    console.error(`steer: delivered to active turn ${payload.activeEventId}`);
+}
+function printGatewayClientHelp() {
+    console.error("messages queue by default; /queue <message> queues explicitly; /steer <message> steers the active turn");
+    console.error("commands: /status, /clear, /abort, /thinking [level], /thinking-show, /goal [command], /help, /quit");
+    console.error("piped EOF waits for acknowledgements and terminal completion of every accepted message while assistant output keeps streaming");
+    console.error("security: raw gateway TCP is unauthenticated and unencrypted; use remote hosts only on trusted networks or through a secure tunnel");
 }
 function isSessionStatus(value) {
     if (!value || typeof value !== "object")
@@ -109,26 +160,237 @@ function printEvent(frame, piboSessionId, state) {
         output.write("assistant> ");
     }
 }
+function isExpectedSubscriptionResponse(frame, piboSessionId) {
+    if (!frame.payload || typeof frame.payload !== "object")
+        return false;
+    const payload = frame.payload;
+    return payload.subscription?.type === "session" && payload.subscription.piboSessionId === piboSessionId;
+}
+function steeringTargetEventId(frame) {
+    if (!frame.payload || typeof frame.payload !== "object")
+        return undefined;
+    const payload = frame.payload;
+    return payload.type === "message_steered" && typeof payload.activeEventId === "string" && payload.activeEventId.length > 0
+        ? payload.activeEventId
+        : undefined;
+}
+function handleGatewayClientLine(value, sendRequest, piboSessionId, renderState) {
+    const text = value.trim();
+    if (!text)
+        return "continue";
+    if (text === "/quit" || text === "/exit")
+        return "quit";
+    if (text === "/help") {
+        printGatewayClientHelp();
+        return "continue";
+    }
+    if (text === "/thinking-show") {
+        renderState.showThinking = !renderState.showThinking;
+        console.error(`thinking display: ${renderState.showThinking ? "on" : "off"}`);
+        return "continue";
+    }
+    if (text === "/thinking" || text.startsWith("/thinking ")) {
+        const level = text.slice("/thinking".length).trim();
+        let params;
+        try {
+            params = level ? { level: parsePiboThinkingLevel(level) } : undefined;
+        }
+        catch (error) {
+            console.error(errorMessage(error));
+            return "error";
+        }
+        sendRequest(params === undefined
+            ? { type: "execution", piboSessionId, action: "thinking" }
+            : { type: "execution", piboSessionId, action: "thinking", params });
+        return "continue";
+    }
+    if (text === "/status" || text === "/clear" || text === "/abort") {
+        const action = text === "/status" ? "status" : text === "/clear" ? "clear_queue" : "abort";
+        sendRequest({ type: "execution", piboSessionId, action });
+        return "continue";
+    }
+    if (text === "/goal" || text.startsWith("/goal ")) {
+        sendRequest({
+            type: "execution",
+            piboSessionId,
+            action: "goal",
+            params: { command: text.slice("/goal".length).trim() },
+        });
+        return "continue";
+    }
+    const message = parseGatewayClientMessage(text);
+    if (!message.ok) {
+        console.error(message.error);
+        return "error";
+    }
+    sendRequest({
+        type: "message",
+        piboSessionId,
+        text: message.text,
+        source: "user",
+        ...(message.delivery ? { delivery: message.delivery } : {}),
+    });
+    return "continue";
+}
 export async function runGatewayClient(options = {}) {
+    const interactive = input.isTTY === true && output.isTTY === true;
     const host = options.host ?? DEFAULT_GATEWAY_HOST;
     const port = options.port ?? DEFAULT_GATEWAY_PORT;
-    const piboSessionId = options.piboSessionId ?? "default";
+    const piboSessionId = (options.piboSessionId ?? "default").trim();
+    const acknowledgementTimeoutMs = options.acknowledgementTimeoutMs ?? DEFAULT_ACKNOWLEDGEMENT_TIMEOUT_MS;
+    const terminalTimeoutMs = options.terminalTimeoutMs ?? DEFAULT_TERMINAL_TIMEOUT_MS;
+    if (!piboSessionId)
+        throw new GatewayClientExpectedError("Pibo Session ID must not be empty");
     const socket = connect({ host, port });
     socket.setEncoding("utf-8");
-    await new Promise((resolve, reject) => {
-        socket.once("connect", resolve);
-        socket.once("error", reject);
-    });
-    console.error(`connected to pibo gateway at ${host}:${port}`);
-    console.error(`session: ${piboSessionId}`);
-    console.error("type a message, /status, /clear, /abort, /thinking [level], /thinking-show, or /quit");
+    try {
+        await new Promise((resolve, reject) => {
+            const onError = (error) => reject(error);
+            socket.once("error", onError);
+            socket.once("connect", () => {
+                socket.off("error", onError);
+                resolve();
+            });
+        });
+    }
+    catch (error) {
+        socket.destroy();
+        throw new GatewayClientExpectedError(`Could not connect to gateway at ${host}:${port}: ${errorMessage(error)}`);
+    }
     let buffer = "";
+    let closing = false;
+    let inputEnded = false;
+    let connectionFailure;
+    let rl;
+    let pendingWaiter;
+    let pipedInputFailed = false;
+    let completedNormally = false;
+    const pendingRequests = new Map();
+    const terminalOutcomes = new Map();
     const renderState = {
         visibleIncomingEventIds: new Set(),
         sawAssistantDelta: false,
         showThinking: false,
         sawThinkingDelta: false,
     };
+    const pendingCount = (kind) => {
+        let count = 0;
+        for (const request of pendingRequests.values()) {
+            if (kind === "acknowledgement" ? !request.acknowledged : request.acknowledged && request.terminalEventId !== undefined) {
+                count += 1;
+            }
+        }
+        return count;
+    };
+    const finishPendingWaiter = (error) => {
+        const waiter = pendingWaiter;
+        if (!waiter)
+            return;
+        pendingWaiter = undefined;
+        clearTimeout(waiter.timeout);
+        if (error)
+            waiter.reject(error);
+        else
+            waiter.resolve();
+    };
+    const notifyPendingWaiter = () => {
+        if (pendingWaiter && pendingCount(pendingWaiter.kind) === 0)
+            finishPendingWaiter();
+    };
+    const waitForPending = async (kind, timeoutMs) => {
+        if (connectionFailure)
+            throw connectionFailure;
+        const count = pendingCount(kind);
+        if (count === 0)
+            return;
+        await new Promise((resolve, reject) => {
+            const label = kind === "acknowledgement" ? "gateway acknowledgement" : "terminal message completion";
+            pendingWaiter = {
+                kind,
+                resolve,
+                reject,
+                timeout: setTimeout(() => {
+                    finishPendingWaiter(new GatewayClientExpectedError(`Timed out waiting for ${pendingCount(kind)} ${label}(s)`));
+                }, timeoutMs),
+            };
+        });
+    };
+    const finishRequestTerminal = (request) => {
+        if (!request.terminalEventId)
+            return;
+        const outcome = terminalOutcomes.get(request.terminalEventId);
+        if (!outcome)
+            return;
+        if (!outcome.ok && !interactive)
+            pipedInputFailed = true;
+        pendingRequests.delete(request.frameId);
+        notifyPendingWaiter();
+    };
+    const recordTerminalOutcome = (event) => {
+        if (interactive || (event.type !== "message_finished" && event.type !== "session_error") || !event.eventId)
+            return;
+        const outcome = event.type === "message_finished"
+            ? { ok: true }
+            : { ok: false, error: event.error };
+        terminalOutcomes.set(event.eventId, outcome);
+        for (const request of [...pendingRequests.values()]) {
+            if (request.terminalEventId === event.eventId)
+                finishRequestTerminal(request);
+        }
+    };
+    const sendRequest = (event) => {
+        const frame = createGatewayClientRequestFrame(event);
+        pendingRequests.set(frame.id, {
+            frameId: frame.id,
+            event: frame.event,
+            acknowledged: false,
+            terminalEventId: !interactive && frame.event.type === "message" && frame.event.delivery !== "steer"
+                ? frame.event.id
+                : undefined,
+        });
+        writeFrame(socket, frame);
+    };
+    const subscriptionFrame = createGatewayClientSubscriptionFrame(piboSessionId);
+    let subscribed = false;
+    let settleSubscription;
+    let subscriptionTimeout;
+    const subscription = new Promise((resolve, reject) => {
+        settleSubscription = (error) => error ? reject(error) : resolve();
+    });
+    const finishSubscription = (error) => {
+        const settle = settleSubscription;
+        if (!settle)
+            return;
+        settleSubscription = undefined;
+        if (subscriptionTimeout)
+            clearTimeout(subscriptionTimeout);
+        settle(error);
+    };
+    subscriptionTimeout = setTimeout(() => {
+        finishSubscription(new GatewayClientExpectedError(`Timed out subscribing to Pibo Session "${piboSessionId}"`));
+    }, acknowledgementTimeoutMs);
+    const failConnection = (error) => {
+        if (!subscribed) {
+            finishSubscription(error);
+            return;
+        }
+        if (closing || connectionFailure || (!interactive && inputEnded && pendingRequests.size === 0))
+            return;
+        connectionFailure = error;
+        finishPendingWaiter(error);
+        rl?.close();
+    };
+    socket.on("error", (error) => {
+        failConnection(new GatewayClientExpectedError(`Gateway connection error: ${errorMessage(error)}`));
+    });
+    socket.on("close", () => {
+        const acknowledgements = pendingCount("acknowledgement");
+        const terminals = pendingCount("terminal");
+        const suffix = acknowledgements > 0 || terminals > 0
+            ? ` before ${acknowledgements} acknowledgement(s) and ${terminals} terminal completion(s)`
+            : "";
+        failConnection(new GatewayClientExpectedError(`Gateway connection closed${suffix}`));
+    });
     socket.on("data", (chunk) => {
         buffer += chunk;
         let newlineIndex = buffer.indexOf("\n");
@@ -136,73 +398,114 @@ export async function runGatewayClient(options = {}) {
             const line = buffer.slice(0, newlineIndex).trim();
             buffer = buffer.slice(newlineIndex + 1);
             const frame = line ? parseJsonLine(line) : undefined;
-            if (frame?.type === "res") {
+            if (frame?.type === "res" && frame.id === subscriptionFrame.id) {
+                if (!frame.ok) {
+                    finishSubscription(new GatewayClientExpectedError(frame.error?.message ?? "Gateway rejected the session subscription"));
+                }
+                else if (!isExpectedSubscriptionResponse(frame, piboSessionId)) {
+                    finishSubscription(new GatewayClientExpectedError("Gateway returned a mismatched session subscription"));
+                }
+                else {
+                    subscribed = true;
+                    finishSubscription();
+                }
+            }
+            else if (subscribed && frame?.type === "res") {
                 printResponse(frame);
+                const request = pendingRequests.get(frame.id);
+                if (request) {
+                    request.acknowledged = true;
+                    if (!frame.ok) {
+                        if (!interactive)
+                            pipedInputFailed = true;
+                        pendingRequests.delete(frame.id);
+                    }
+                    else if (request.event.type === "message") {
+                        if (request.event.delivery === "steer") {
+                            const activeEventId = steeringTargetEventId(frame);
+                            if (!activeEventId) {
+                                console.error("\nerror: gateway steering acknowledgement did not identify the active turn");
+                                if (!interactive)
+                                    pipedInputFailed = true;
+                                pendingRequests.delete(frame.id);
+                            }
+                            else if (interactive) {
+                                pendingRequests.delete(frame.id);
+                            }
+                            else {
+                                request.terminalEventId = activeEventId;
+                                finishRequestTerminal(request);
+                            }
+                        }
+                        else if (interactive) {
+                            pendingRequests.delete(frame.id);
+                        }
+                        else {
+                            finishRequestTerminal(request);
+                        }
+                    }
+                    else {
+                        pendingRequests.delete(frame.id);
+                    }
+                    notifyPendingWaiter();
+                }
             }
-            else if (frame?.type === "event") {
+            else if (subscribed && frame?.type === "event") {
                 printEvent(frame, piboSessionId, renderState);
+                recordTerminalOutcome(frame.payload);
             }
             newlineIndex = buffer.indexOf("\n");
         }
     });
-    const rl = readline.createInterface({ input, output });
+    writeFrame(socket, subscriptionFrame);
     try {
-        while (!socket.destroyed) {
-            const text = (await rl.question("you> ")).trim();
-            if (!text)
-                continue;
-            if (text === "/quit" || text === "/exit")
+        await subscription;
+    }
+    catch (error) {
+        closing = true;
+        socket.destroy();
+        throw error;
+    }
+    if (connectionFailure || socket.destroyed) {
+        closing = true;
+        socket.destroy();
+        throw connectionFailure ?? new GatewayClientExpectedError("Gateway connection closed");
+    }
+    console.error(`connected to pibo gateway at ${host}:${port}`);
+    console.error(`session: ${piboSessionId}`);
+    printGatewayClientHelp();
+    rl = readline.createInterface({ input, output, terminal: interactive });
+    if (interactive) {
+        rl.setPrompt("you> ");
+        rl.prompt();
+    }
+    try {
+        for await (const line of rl) {
+            const result = handleGatewayClientLine(line, sendRequest, piboSessionId, renderState);
+            if (result === "error" && !interactive)
+                pipedInputFailed = true;
+            if (result === "quit")
                 break;
-            if (text === "/thinking-show") {
-                renderState.showThinking = !renderState.showThinking;
-                console.error(`thinking display: ${renderState.showThinking ? "on" : "off"}`);
-                continue;
-            }
-            if (text === "/thinking" || text.startsWith("/thinking ")) {
-                const level = text.slice("/thinking".length).trim();
-                let params;
-                try {
-                    params = level ? { level: parsePiboThinkingLevel(level) } : undefined;
-                }
-                catch (error) {
-                    console.error(error instanceof Error ? error.message : String(error));
-                    continue;
-                }
-                writeFrame(socket, {
-                    type: "req",
-                    id: randomUUID(),
-                    event: params === undefined
-                        ? { type: "execution", piboSessionId, action: "thinking" }
-                        : { type: "execution", piboSessionId, action: "thinking", params },
-                });
-                continue;
-            }
-            if (text === "/status" || text === "/clear" || text === "/abort") {
-                const action = text === "/status" ? "status" : text === "/clear" ? "clear_queue" : "abort";
-                writeFrame(socket, {
-                    type: "req",
-                    id: randomUUID(),
-                    event: { type: "execution", piboSessionId, action },
-                });
-                continue;
-            }
-            if (text === "/goal" || text.startsWith("/goal ")) {
-                writeFrame(socket, {
-                    type: "req",
-                    id: randomUUID(),
-                    event: { type: "execution", piboSessionId, action: "goal", params: { command: text.slice("/goal".length).trim() } },
-                });
-                continue;
-            }
-            writeFrame(socket, {
-                type: "req",
-                id: randomUUID(),
-                event: { type: "message", piboSessionId, text, source: "user" },
-            });
+            if (interactive && !socket.destroyed)
+                rl.prompt();
+        }
+        inputEnded = true;
+        if (!interactive) {
+            await waitForPending("acknowledgement", acknowledgementTimeoutMs);
+            await waitForPending("terminal", terminalTimeoutMs);
         }
+        completedNormally = true;
     }
     finally {
+        closing = true;
         rl.close();
-        socket.end();
+        if (completedNormally)
+            socket.end();
+        else
+            socket.destroy();
     }
+    if (connectionFailure)
+        throw connectionFailure;
+    if (!interactive && pipedInputFailed)
+        process.exitCode = 1;
 }

package/dist/gateway/protocol.js

@@ -16,6 +16,8 @@ function isJsonValue(value) {
     return false;
 }
 export function isGatewayRequestFrame(value) {
+    // Keep this unversioned wire validator compatible with existing clients. Stricter
+    // message text, delivery, and identifier validation belongs at client boundaries.
     if (!value || typeof value !== "object")
         return false;
     const frame = value;