@giovannijecha/jecode 0.8.2 → 0.8.4

package/dist/sessions/store.js

@@ -4,12 +4,12 @@
 // after that node is durable, so a crash leaves either the prior checkpoint or
 // one strictly recoverable mutation -- never an ambiguous partial history.
 import { createHash, randomUUID } from "node:crypto";
-import { chmod, lstat, mkdir, open, opendir, readFile, readdir, realpath, rename, rm, stat, } from "node:fs/promises";
+import { chmod, lstat, mkdir, open, opendir, readFile, readdir, realpath, rename, rm, } from "node:fs/promises";
 import * as path from "node:path";
 import { atomicWrite } from "../atomic.js";
 import { CONVERSATION_LIMITS, ConversationTree } from "../conversation.js";
-import { leadingText } from "../text-boundary.js";
 import { userDataPath } from "../user-data.js";
+import { advanceSessionCatalog, catalogMatches, decodeSessionCatalog, encodeSessionCatalog, sameSessionHead, sessionCatalog, SESSION_CATALOG_BYTES, SESSION_CATALOG_FILE, SESSION_CHECKPOINT_FILE, } from "./catalog.js";
 import { decodeHead, decodeMeta, decodeNode, encodeHead, encodeMeta, encodeNode, SESSION_FILE_LIMITS, SESSION_SCHEMA, } from "./codec.js";
 import { leaseOwner, leaseToken, pidIsAlive, removeLease, sessionLease, } from "./lease.js";
 const DIRECTORY_MODE = 0o700;
@@ -44,24 +44,7 @@ export class DurableSessionStore {
         for (let start = 0; start < names.length; start += CATALOG_READ_CONCURRENCY) {
             const batch = await Promise.all(names.slice(start, start + CATALOG_READ_CONCURRENCY)
                 .map(async (id) => {
-                try {
-                    const snapshot = await this.load(id);
-                    const conversation = snapshot.conversation.latestResumable();
-                    if (conversation === undefined)
-                        return undefined;
-                    return {
-                        id,
-                        createdAt: snapshot.meta.createdAt,
-                        updatedAt: snapshot.head.updatedAt,
-                        turns: selectedTurnCount(conversation),
-                        preview: firstUserText(conversation),
-                        active: await this.#leaseIsActive(id),
-                    };
-                }
-                catch {
-                    // Corrupt or foreign data never becomes a resume candidate.
-                    return undefined;
-                }
+                return await this.#catalogEntry(id);
             }));
             catalog.push(...batch.filter((entry) => entry !== undefined));
         }
@@ -74,9 +57,7 @@ export class DurableSessionStore {
         const directory = this.#sessionDirectory(id);
         await assertDirectory(directory);
         const meta = decodeMeta(await readJson(path.join(directory, "meta.json"), SESSION_FILE_LIMITS.metadataBytes));
-        if (meta.id !== id || meta.workspaceDigest !== this.workspaceDigest ||
-            workspaceKey(meta.workspaceRoot) !== workspaceKey(this.workspaceRoot))
-            throw new Error("session belongs to a different workspace");
+        assertSessionWorkspace(meta, id, this.workspaceRoot, this.workspaceDigest);
         let head = decodeHead(await readJson(path.join(directory, "head.json"), SESSION_FILE_LIMITS.metadataBytes));
         const stored = await readNodes(path.join(directory, "nodes"));
         const ahead = stored.filter((entry) => entry.sequence > head.sequence);
@@ -105,19 +86,23 @@ export class DurableSessionStore {
             if (!replacesHead && !extendsTree) {
                 throw new Error("session checkpoint cannot be recovered safely");
             }
-            head = {
+            head = Object.freeze({
                 version: SESSION_SCHEMA,
                 sequence: candidate.sequence,
                 nodeId: candidate.node.id,
                 parentId: candidate.node.parentId,
                 revision: candidate.node.revision,
                 updatedAt: candidate.updatedAt,
-            };
-            await atomicWrite(path.join(directory, "head.json"), encodeHead(head), { mode: FILE_MODE });
+            });
+            await atomicWrite(path.join(directory, "head.json"), encodeHead(head), {
+                mode: FILE_MODE,
+                validate: async () => assertDirectory(directory),
+            });
         }
         const nodes = stored.map((entry) => entry.node);
         const conversation = ConversationTree.restore(nodes, head.nodeId);
-        return Object.freeze({ meta, head, conversation });
+        const catalog = sessionCatalog(meta, head, conversation);
+        return Object.freeze({ meta, head, conversation, catalog });
     }
     async publish(conversation, claim) {
         const active = conversation.activeNode;
@@ -129,21 +114,22 @@ export class DurableSessionStore {
         const token = claim === true ? leaseToken() : undefined;
         const temporary = path.join(this.#bucket, `.${id}.${randomUUID()}.tmp`);
         const target = this.#sessionDirectory(id);
-        const meta = {
+        const meta = Object.freeze({
             version: SESSION_SCHEMA,
             id,
             workspaceRoot: this.workspaceRoot,
             workspaceDigest: this.workspaceDigest,
             createdAt: now,
-        };
-        const head = {
+        });
+        const head = Object.freeze({
             version: SESSION_SCHEMA,
             sequence: conversation.nodes.length,
             nodeId: active.id,
             parentId: active.parentId,
             revision: active.revision,
             updatedAt: now,
-        };
+        });
+        const catalog = sessionCatalog(meta, head, conversation);
         try {
             await makePrivateDirectory(temporary);
             const nodes = path.join(temporary, "nodes");
@@ -154,6 +140,7 @@ export class DurableSessionStore {
             }
             await atomicWrite(path.join(temporary, "meta.json"), encodeMeta(meta), { mode: FILE_MODE });
             await atomicWrite(path.join(temporary, "head.json"), encodeHead(head), { mode: FILE_MODE });
+            await atomicWrite(path.join(temporary, SESSION_CATALOG_FILE), encodeSessionCatalog(catalog), { mode: FILE_MODE });
             if (token !== undefined) {
                 await atomicWrite(path.join(temporary, "active"), token, { mode: FILE_MODE });
             }
@@ -163,18 +150,32 @@ export class DurableSessionStore {
             await removeTemporaryDirectory(temporary, this.#bucket);
             throw error;
         }
-        const snapshot = Object.freeze({ meta, head, conversation });
+        const snapshot = Object.freeze({ meta, head, conversation, catalog });
         if (token === undefined)
             return snapshot;
         const lease = sessionLease(id, path.join(target, "active"), token);
         return Object.freeze({ ...snapshot, lease });
     }
-    async checkpoint(id, conversation) {
-        const previous = await this.load(id);
+    async checkpoint(previous, conversation) {
+        assertSnapshot(previous, this.workspaceRoot, this.workspaceDigest);
+        const id = previous.meta.id;
+        const directory = this.#sessionDirectory(id);
+        await assertDirectory(directory);
+        const nodesDirectory = path.join(directory, "nodes");
+        const validateNodesDirectory = async () => {
+            await assertDirectory(directory);
+            await assertDirectory(nodesDirectory);
+        };
+        await validateNodesDirectory();
+        const currentHead = decodeHead(await readJson(path.join(directory, "head.json"), SESSION_FILE_LIMITS.metadataBytes));
+        if (!sameSessionHead(currentHead, previous.head)) {
+            throw new Error("session head changed after its verified snapshot");
+        }
         const active = conversation.activeNode;
         if (active === undefined)
             throw new Error("an empty conversation cannot be checkpointed");
-        if (sameNode(active, previous.conversation.activeNode)) {
+        if (active === previous.conversation.activeNode &&
+            conversation.nodes === previous.conversation.nodes) {
             return Object.freeze({ ...previous, conversation });
         }
         const replacesHead = active.id === previous.head.nodeId &&
@@ -187,19 +188,31 @@ export class DurableSessionStore {
             throw new Error("session checkpoint does not extend its durable tree");
         }
         assertSharedNodes(previous.conversation, conversation, replacesHead ? active.id : undefined);
+        if (extendsTree) {
+            await assertMissingNode(path.join(nodesDirectory, nodeName(active.id)));
+        }
         const now = new Date().toISOString();
-        const head = {
+        const head = Object.freeze({
             version: SESSION_SCHEMA,
             sequence: previous.head.sequence + 1,
             nodeId: active.id,
             parentId: active.parentId,
             revision: active.revision,
             updatedAt: now,
-        };
-        const directory = this.#sessionDirectory(id);
-        await atomicWrite(path.join(directory, "nodes", nodeName(active.id)), encodeNode(active, head.sequence, now), { mode: FILE_MODE });
-        await atomicWrite(path.join(directory, "head.json"), encodeHead(head), { mode: FILE_MODE });
-        return Object.freeze({ meta: previous.meta, head, conversation });
+        });
+        const catalog = advanceSessionCatalog(previous.catalog, previous.meta, head, conversation);
+        const checkpointToken = leaseToken();
+        await atomicWrite(path.join(directory, SESSION_CHECKPOINT_FILE), checkpointToken, { mode: FILE_MODE, validate: async () => assertDirectory(directory) });
+        await atomicWrite(path.join(nodesDirectory, nodeName(active.id)), encodeNode(active, head.sequence, now), { mode: FILE_MODE, validate: async () => validateNodesDirectory() });
+        await atomicWrite(path.join(directory, "head.json"), encodeHead(head), {
+            mode: FILE_MODE,
+            validate: async () => assertDirectory(directory),
+        });
+        await this.#writeCatalog(previous.meta.id, catalog, checkpointToken).catch(() => undefined);
+        // Once the canonical head is durable, a missing summary is detectable by
+        // its head mismatch and can be rebuilt without retaining a live marker.
+        await removeLease(path.join(directory, SESSION_CHECKPOINT_FILE), checkpointToken);
+        return Object.freeze({ meta: previous.meta, head, conversation, catalog });
     }
     async claim(id) {
         assertSessionId(id);
@@ -243,6 +256,74 @@ export class DurableSessionStore {
         const owner = await leaseOwner(path.join(this.#sessionDirectory(id), "active"));
         return owner !== undefined && pidIsAlive(owner.pid);
     }
+    async #catalogEntry(id) {
+        try {
+            const directory = this.#sessionDirectory(id);
+            await assertDirectory(directory);
+            const checkpointFile = path.join(directory, SESSION_CHECKPOINT_FILE);
+            // A second head read closes the only useful race: a checkpoint landing
+            // between the small record reads. A changing marker gets one retry.
+            for (let attempt = 0; attempt < 2; attempt++) {
+                const checkpointBefore = await leaseOwner(checkpointFile);
+                try {
+                    const [metaValue, headValue, catalogValue] = await Promise.all([
+                        readJson(path.join(directory, "meta.json"), SESSION_FILE_LIMITS.metadataBytes),
+                        readJson(path.join(directory, "head.json"), SESSION_FILE_LIMITS.metadataBytes),
+                        readJson(path.join(directory, SESSION_CATALOG_FILE), SESSION_CATALOG_BYTES),
+                    ]);
+                    const meta = decodeMeta(metaValue);
+                    const head = decodeHead(headValue);
+                    const storedCatalog = decodeSessionCatalog(catalogValue);
+                    assertSessionWorkspace(meta, id, this.workspaceRoot, this.workspaceDigest);
+                    const confirmedHead = decodeHead(await readJson(path.join(directory, "head.json"), SESSION_FILE_LIMITS.metadataBytes));
+                    const checkpointAfter = await leaseOwner(checkpointFile);
+                    if (!sameLease(checkpointBefore, checkpointAfter))
+                        continue;
+                    if (!sameSessionHead(head, confirmedHead) ||
+                        !catalogMatches(storedCatalog, meta, head))
+                        break;
+                    if (checkpointAfter !== undefined && !pidIsAlive(checkpointAfter.pid))
+                        break;
+                    const active = await this.#leaseIsActive(id) || checkpointAfter !== undefined;
+                    return catalogEntry(storedCatalog, active);
+                }
+                catch {
+                    break;
+                }
+            }
+            // Missing, stale, or malformed summaries are rebuilt only while the
+            // session is idle. Selecting a session still performs this strict load.
+            const checkpoint = await leaseOwner(checkpointFile);
+            if (await this.#leaseIsActive(id) ||
+                (checkpoint !== undefined && pidIsAlive(checkpoint.pid)))
+                return undefined;
+            const snapshot = await this.load(id);
+            await this.#writeCatalog(id, snapshot.catalog, checkpoint?.token).catch(() => undefined);
+            const currentCheckpoint = await leaseOwner(checkpointFile);
+            const active = await this.#leaseIsActive(id) ||
+                (currentCheckpoint !== undefined && pidIsAlive(currentCheckpoint.pid));
+            return catalogEntry(snapshot.catalog, active);
+        }
+        catch {
+            // Corrupt, unsafe, active-without-a-summary, or foreign data never
+            // becomes a resume candidate.
+            return undefined;
+        }
+    }
+    async #writeCatalog(id, catalog, checkpointToken) {
+        const directory = this.#sessionDirectory(id);
+        const validate = async () => {
+            await assertDirectory(directory);
+            const currentHead = decodeHead(await readJson(path.join(directory, "head.json"), SESSION_FILE_LIMITS.metadataBytes));
+            if (!sameSessionHead(currentHead, catalog.head)) {
+                throw new Error("session head changed while updating its catalogue");
+            }
+        };
+        await atomicWrite(path.join(directory, SESSION_CATALOG_FILE), encodeSessionCatalog(catalog), { mode: FILE_MODE, validate });
+        if (checkpointToken !== undefined) {
+            await removeLease(path.join(directory, SESSION_CHECKPOINT_FILE), checkpointToken);
+        }
+    }
 }
 async function catalogNames(directory) {
     try {
@@ -266,22 +347,65 @@ async function catalogNames(directory) {
     }
     return names.sort((left, right) => right.localeCompare(left));
 }
+function catalogEntry(catalog, active) {
+    if (catalog.resumeNodeId === 0)
+        return undefined;
+    return Object.freeze({
+        id: catalog.id,
+        createdAt: catalog.createdAt,
+        updatedAt: catalog.head.updatedAt,
+        turns: catalog.turns,
+        preview: catalog.preview,
+        active,
+    });
+}
+function sameLease(left, right) {
+    return left?.token === right?.token;
+}
+function assertSessionWorkspace(meta, id, workspaceRoot, workspaceDigest) {
+    if (meta.id !== id || meta.workspaceDigest !== workspaceDigest ||
+        workspaceKey(meta.workspaceRoot) !== workspaceKey(workspaceRoot))
+        throw new Error("session belongs to a different workspace");
+}
 function assertSharedNodes(previous, next, replacedId) {
     for (const node of previous.nodes) {
         if (node.id === replacedId)
             continue;
         const candidate = next.node(node.id);
-        if (candidate === undefined || normalizedNode(candidate) !== normalizedNode(node)) {
+        if (candidate !== node) {
             throw new Error("session checkpoint rewrites prior conversation history");
         }
     }
 }
-function normalizedNode(node) {
-    const encoded = JSON.parse(encodeNode(node, 1, "2026-01-01T00:00:00.000Z"));
-    return JSON.stringify(encoded.node);
+function assertSnapshot(snapshot, workspaceRoot, workspaceDigest) {
+    encodeMeta(snapshot.meta);
+    encodeHead(snapshot.head);
+    encodeSessionCatalog(snapshot.catalog);
+    assertSessionId(snapshot.meta.id);
+    if (snapshot.meta.workspaceDigest !== workspaceDigest ||
+        workspaceKey(snapshot.meta.workspaceRoot) !== workspaceKey(workspaceRoot))
+        throw new Error("session snapshot belongs to a different workspace");
+    const active = snapshot.conversation.activeNode;
+    if (active === undefined ||
+        active.id !== snapshot.head.nodeId ||
+        active.parentId !== snapshot.head.parentId ||
+        active.revision !== snapshot.head.revision ||
+        snapshot.head.sequence < snapshot.conversation.nodes.length)
+        throw new Error("session snapshot does not match its verified head");
+    if (!catalogMatches(snapshot.catalog, snapshot.meta, snapshot.head)) {
+        throw new Error("session snapshot does not match its verified catalogue");
+    }
 }
-function sameNode(left, right) {
-    return right !== undefined && normalizedNode(left) === normalizedNode(right);
+async function assertMissingNode(file) {
+    try {
+        await lstat(file);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    throw new Error("session has an incomplete node outside its verified snapshot");
 }
 async function readNodes(directory) {
     await assertDirectory(directory);
@@ -344,17 +468,6 @@ async function makePrivateDirectory(directory) {
     if (process.platform !== "win32")
         await chmod(directory, DIRECTORY_MODE);
 }
-async function directoryEntries(directory) {
-    try {
-        await assertDirectory(directory);
-        return await readdir(directory, { withFileTypes: true });
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return [];
-        throw error;
-    }
-}
 async function removeTemporaryDirectory(directory, bucket) {
     const relative = path.relative(bucket, directory);
     if (relative === "" || relative.startsWith("..") || path.isAbsolute(relative) ||
@@ -362,26 +475,6 @@ async function removeTemporaryDirectory(directory, bucket) {
         throw new Error("refusing to remove an unverified session directory");
     await rm(directory, { recursive: true, force: true });
 }
-function selectedTurnCount(conversation) {
-    let count = 0;
-    let id = conversation.activeNodeId;
-    while (id !== 0) {
-        count++;
-        id = conversation.node(id)?.parentId ?? 0;
-    }
-    return count;
-}
-function firstUserText(conversation) {
-    for (const message of conversation.history) {
-        if (message.role !== "user")
-            continue;
-        const text = message.content.find((block) => block.kind === "text")?.text
-            .replace(/\s+/gu, " ").trim();
-        if (text !== undefined && text !== "")
-            return leadingText(text, 160);
-    }
-    return "Untitled session";
-}
 function nodeName(id) {
     return `${String(id).padStart(6, "0")}.json`;
 }

package/dist/settings.js

@@ -1,5 +1,4 @@
 // Persistent, non-secret defaults for interactive and batch sessions.
-import { readFileSync } from "node:fs";
 import { chmod, mkdir } from "node:fs/promises";
 import * as path from "node:path";
 import { atomicWrite } from "./atomic.js";
@@ -9,6 +8,7 @@ import { providerNames } from "./providers/index.js";
 import { parseOllamaEndpoint } from "./providers/ollama-endpoint.js";
 import { withStoreLock } from "./store-lock.js";
 import { userDataLabel, userDataPath } from "./user-data.js";
+import { assertStoreText, readBoundedJsonSync, USER_STORE_LIMITS } from "./user-store.js";
 export { EFFORTS } from "./effort.js";
 let saved;
 export function readSettings() {
@@ -24,7 +24,9 @@ export async function updateSettings(patch) {
         await chmod(directory, 0o700);
     return withStoreLock(file, async () => {
         const next = normalize({ ...readStore(file), ...patch });
-        await atomicWrite(file, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+        const text = `${JSON.stringify(next, null, 2)}\n`;
+        assertStoreText(text, USER_STORE_LIMITS.settingsBytes);
+        await atomicWrite(file, text, { mode: 0o600 });
         saved = next;
         return file;
     });
@@ -41,7 +43,7 @@ export function reloadSettings() {
 }
 function readStore(file = settingsPath()) {
     try {
-        return normalize(JSON.parse(readFileSync(file, "utf8")));
+        return normalize(readBoundedJsonSync(file, USER_STORE_LIMITS.settingsBytes));
     }
     catch {
         // Missing, unreadable, and malformed stores all fall back safely. A bad
@@ -73,14 +75,14 @@ function normalize(value) {
 function modelsOf(value, providers) {
     if (!record(value))
         return undefined;
-    const models = Object.fromEntries(Object.entries(value).filter((entry) => providers.includes(entry[0]) && typeof entry[1] === "string" && entry[1].trim() !== ""));
+    const models = Object.fromEntries(Object.entries(value).filter((entry) => providers.includes(entry[0]) && boundedNonempty(entry[1], USER_STORE_LIMITS.model)));
     return Object.keys(models).length === 0 ? undefined : models;
 }
 function member(value, values) {
     return typeof value === "string" && values.includes(value) ? value : undefined;
 }
 function endpoint(value) {
-    if (typeof value !== "string")
+    if (!boundedNonempty(value, USER_STORE_LIMITS.endpoint))
         return undefined;
     try {
         return parseOllamaEndpoint(value).baseUrl;
@@ -89,6 +91,9 @@ function endpoint(value) {
         return undefined;
     }
 }
+function boundedNonempty(value, max) {
+    return typeof value === "string" && value.length <= max && value.trim() !== "";
+}
 function positiveInteger(value) {
     return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
 }

package/dist/start.js

@@ -76,14 +76,24 @@ export async function start(args = process.argv.slice(2), environment = {}) {
             }
         }
         try {
-            await (environment.runInteractive ?? runApp)(session, transcriptRoot);
+            if (environment.runInteractive === undefined) {
+                await runApp(session, transcriptRoot, { shutdownSignal: environment.signal });
+            }
+            else {
+                await environment.runInteractive(session, transcriptRoot, environment.signal);
+            }
         }
         finally {
             await session.persistence?.close();
         }
     }
     else {
-        await (environment.runNonInteractive ?? runBatch)(session);
+        if (environment.runNonInteractive === undefined) {
+            await runBatch(session, { signal: environment.signal });
+        }
+        else {
+            await environment.runNonInteractive(session, environment.signal);
+        }
     }
 }
 function applyResumedSession(session, conversation, persistence) {

package/dist/text-boundary.js

@@ -1,5 +1,7 @@
 // Shared grapheme boundaries for every projection of user-visible text.
 const SEGMENTER = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+/** Shared persisted-text and user-prompt boundary, measured like String.length. */
+export const MAX_TEXT_CODE_UNITS = 1_048_576;
 export function segmentGraphemes(text) {
     return SEGMENTER.segment(text);
 }

package/dist/tools/search.js

@@ -232,11 +232,10 @@ function preferRipgrep(files, bytes) {
     return files.length >= MIN_RG_TAIL_FILES || bytes >= MIN_RG_TAIL_BYTES;
 }
 async function walk(start, ctx, visit) {
-    const pending = [start];
+    const pending = [];
     let seen = 0;
-    while (pending.length > 0) {
+    const enter = async (lexical) => {
         checkAbort(ctx.signal);
-        const lexical = pending.pop();
         const directory = await resolveExistingInRoot(ctx.root, lexical);
         let entries;
         try {
@@ -244,24 +243,34 @@ async function walk(start, ctx, visit) {
         }
         catch (error) {
             if (skippable(error))
-                continue;
+                return;
             throw error;
         }
         entries.sort((a, b) => a.name.localeCompare(b.name));
-        for (const entry of entries) {
-            checkAbort(ctx.signal);
-            if (++seen > MAX_VISITED)
-                return { capped: true };
-            if (entry.isSymbolicLink())
-                continue;
-            const target = path.join(directory, entry.name);
-            if (entry.isDirectory()) {
-                if (!SKIP.has(entry.name))
-                    pending.push(target);
-            }
-            else if (entry.isFile() && (await visit(target))) {
-                return { capped: false };
-            }
+        pending.push({ directory, entries, next: 0 });
+    };
+    await enter(start);
+    while (pending.length > 0) {
+        checkAbort(ctx.signal);
+        const frame = pending[pending.length - 1];
+        if (frame === undefined)
+            break;
+        const entry = frame.entries[frame.next++];
+        if (entry === undefined) {
+            pending.pop();
+            continue;
+        }
+        if (++seen > MAX_VISITED)
+            return { capped: true };
+        if (entry.isSymbolicLink())
+            continue;
+        const target = path.join(frame.directory, entry.name);
+        if (entry.isDirectory()) {
+            if (!SKIP.has(entry.name))
+                await enter(target);
+        }
+        else if (entry.isFile() && (await visit(target))) {
+            return { capped: false };
         }
     }
     return { capped: false };

package/dist/tui/app-input.js

@@ -1,4 +1,5 @@
 // Keyboard and pointer intent for the TUI shell.
+import { PROMPT_LIMIT_MESSAGE, PromptLimitError } from "../input-boundary.js";
 import { activate as activateCompletion, move as moveCompletion, selected as selectedCompletion, } from "./complete.js";
 import * as edit from "./editor.js";
 import { turnBlocker } from "./feedback.js";
@@ -21,6 +22,13 @@ export function appInput(options) {
         }
         if (state.feedback !== undefined)
             feedback.dismiss();
+        if (key.name === "input_limit") {
+            if (state.open === undefined)
+                rejectPrompt();
+            else
+                showInputLimit();
+            return;
+        }
         // Detail expansion remains available while an approval is open. A large
         // diff may be compacted, but the user must be able to inspect it before
         // answering the permission prompt.
@@ -33,6 +41,8 @@ export function appInput(options) {
         if (state.open !== undefined) {
             const outcome = overlay.handle(state.open, key);
             state.open = outcome.open;
+            if (outcome.inputLimit === true)
+                showInputLimit();
             if (outcome.abort === true)
                 state.activity?.control.abort(new Error("interrupted"));
             if (outcome.quit === true)
@@ -61,8 +71,10 @@ export function appInput(options) {
             case "enter": {
                 if (state.completing !== undefined) {
                     const completed = selectedCompletion(state.completing);
-                    if (completed !== undefined)
+                    if (completed !== undefined) {
                         state.editor = edit.of(completed);
+                        state.promptRejected = false;
+                    }
                     state.completing = undefined;
                 }
                 submit();
@@ -75,6 +87,7 @@ export function appInput(options) {
                 const completed = completion === undefined ? undefined : selectedCompletion(completion);
                 if (completed !== undefined) {
                     state.editor = edit.of(completed);
+                    state.promptRejected = false;
                     state.completing = undefined;
                 }
                 return;
@@ -106,16 +119,26 @@ export function appInput(options) {
             options.invalidate();
             return;
         }
-        const edited = applyKey(state.editor, key);
-        if (edited !== undefined) {
-            state.editor = edited;
-            state.completing = state.activity === undefined ? activateCompletion(edited.text) : undefined;
+        try {
+            const edited = applyKey(state.editor, key);
+            if (edited !== undefined) {
+                if (edited.text !== state.editor.text)
+                    state.promptRejected = false;
+                state.editor = edited;
+                state.completing = state.activity === undefined ? activateCompletion(edited.text) : undefined;
+            }
+        }
+        catch (error) {
+            if (!(error instanceof PromptLimitError))
+                throw error;
+            rejectPrompt();
         }
     }
     function recall(step) {
         if (state.past.length === 0)
             return;
         state.completing = undefined;
+        state.promptRejected = false;
         if (state.recall === -1) {
             if (step > 0)
                 return;
@@ -132,6 +155,10 @@ export function appInput(options) {
         state.editor = edit.of(state.past[state.recall]);
     }
     function submit() {
+        if (state.promptRejected) {
+            keep(PROMPT_LIMIT_MESSAGE);
+            return;
+        }
         const text = state.editor.text.trim();
         if (text === "")
             return;
@@ -171,6 +198,7 @@ export function appInput(options) {
         state.recall = -1;
         state.draft = "";
         state.completing = undefined;
+        state.promptRejected = false;
         state.past.push(text);
         state.scroll = 0;
         state.follow = true;
@@ -179,5 +207,12 @@ export function appInput(options) {
     function keep(text) {
         feedback.show({ text: `${text} · prompt kept`, tone: "warn", timeoutMs: 4_000 });
     }
+    function rejectPrompt() {
+        state.promptRejected = true;
+        keep(PROMPT_LIMIT_MESSAGE);
+    }
+    function showInputLimit() {
+        feedback.show({ text: PROMPT_LIMIT_MESSAGE, tone: "warn", timeoutMs: 4_000 });
+    }
     return { handle };
 }

package/dist/tui/app-state.js

@@ -13,5 +13,6 @@ export function appState() {
         draft: "",
         closeWhenIdle: false,
         committedNodeId: 0,
+        promptRejected: false,
     };
 }

package/dist/tui/app-workflows.js

@@ -212,6 +212,7 @@ export function appWorkflows(options) {
                 nodeId: nodeId ?? prospectiveNodeId,
                 coveredMessages: context?.messageCount ?? 0,
                 lastInputTokens: Math.max(session.usage.lastInputTokens, request.inputTokens),
+                estimatedInputTokens: request.inputTokens,
                 signal: activity.control.signal,
                 force,
                 policy: request.policy,