@giovannijecha/jecode 0.7.1 → 0.7.2

package/README.md

@@ -168,7 +168,7 @@ Type `/` to open searchable command completion inside the composer.
 | `/providers` | Manage provider connections, API keys, ChatGPT sign-in, and Ollama endpoints |
 | `/models` | Search all currently usable provider catalogues and select a model |
 | `/permissions` | Change session tool access and review remembered approvals |
-| `/timeline` | Browse completed turns and select where the next branch should begin |
+| `/timeline` | Browse resumable turns and select where the next branch should begin |
 | `/compact` | Compact the current branch context without deleting saved conversation history |
 | `/new` | Start a new conversation and reset session tool permissions |
 | `/export` | Save a timestamped Markdown transcript in the launch directory |
@@ -203,13 +203,16 @@ the resume picker until it has a settled turn. Resuming and continuing a
 conversation keeps its durable session identity and updates one picker entry
 instead of creating duplicates.
 
-`/timeline` shows completed turns in the conversation tree. Selecting an older
-turn changes only the in-memory path: it creates and saves a branch only after
-the next real user message. Cancelling the picker or exiting before that message
-leaves the durable head unchanged. Historical tools are displayed but never
-executed. If a crash interrupted a tool loop, Jecode resumes from the latest
-completed ancestor and lets the next user turn create a branch. `/export`
-writes only the currently selected path.
+`/timeline` shows completed, failed, and interrupted turns in the conversation
+tree. Selecting an older turn changes only the in-memory path: it creates and
+saves a branch only after the next real user message. Cancelling the picker or
+exiting before that message leaves the durable head unchanged. A failed turn
+keeps the same partial evidence and outcome in the live transcript, export, and
+resume, while the next model receives a neutral failure boundary instead of
+incomplete streamed text. Historical tools are displayed but never executed.
+If a process stops abruptly inside a tool loop, Jecode resumes from the latest
+safe ancestor and lets the next user turn create a branch. `/export` writes
+only the currently selected path.
 
 When model-facing context approaches the selected model's usable capacity,
 Jecode asks the provider for a bounded summary of the older prefix and keeps
@@ -289,8 +292,9 @@ untrusted data.
 - Provider handshakes and idle response bodies have finite deadlines. Only
   idempotent catalogue reads retry; generation requests are never replayed.
 - Model, terminal, and filesystem input are bounded before use.
-- Session files are versioned, size-bounded, atomically checkpointed, and
-  treated as untrusted when loaded. A live lease prevents concurrent resume.
+- Session files are versioned, symmetrically size-bounded before write and
+  after read, atomically checkpointed, and treated as untrusted when loaded. A
+  live lease prevents concurrent resume.
 
 `run_command` is not an operating-system sandbox. An approved command can still
 access files and account resources available to the current user. Review

package/dist/context/manual.js

@@ -62,6 +62,7 @@ export async function compactSession(session, options = {}) {
         messages: active.messages,
         blocks: active.blocks,
         context: result.anchor,
+        ...(active.failure === undefined ? {} : { failure: active.failure }),
     }, active.settlement);
     await session.persistence?.checkpoint(next);
     session.conversation = next;

package/dist/conversation.js

@@ -5,6 +5,7 @@
 // project an older prefix before it is sent to a provider. Provider traffic
 // and live screen blocks remain prospective until a consistent checkpoint.
 import { projectContext, validContextAnchor } from "./context/projection.js";
+import { assertPersistableNode } from "./sessions/codec.js";
 export const CONVERSATION_LIMITS = Object.freeze({
     nodes: 1_024,
     messageCodeUnits: 8_388_608,
@@ -37,6 +38,7 @@ export class ConversationTree {
                 messages: node.messages,
                 blocks: node.blocks,
                 ...(node.context === undefined ? {} : { context: node.context }),
+                ...(node.failure === undefined ? {} : { failure: node.failure }),
             }, node.settlement);
             const restored = tree.activeNode;
             if (restored === undefined || restored.id !== node.id) {
@@ -92,6 +94,19 @@ export class ConversationTree {
         }
         return undefined;
     }
+    /** Select the newest turn that is safe to continue after a restart. */
+    latestResumable() {
+        let id = this.#activeNodeId;
+        while (id !== 0) {
+            const node = this.node(id);
+            if (node === undefined)
+                throw new Error("conversation path is incomplete");
+            if (node.settlement !== "checkpointed")
+                return this.select(id);
+            id = node.parentId;
+        }
+        return undefined;
+    }
     get history() {
         return this.#path().flatMap((node) => clone(node.messages));
     }
@@ -99,7 +114,12 @@ export class ConversationTree {
         return projectContext(this.#path());
     }
     get transcript() {
-        return this.#path().flatMap((node) => clone(node.blocks));
+        return this.#path().flatMap((node) => [
+            ...clone(node.blocks),
+            ...(node.failure === undefined
+                ? []
+                : [{ kind: "notice", text: node.failure.text, tone: node.failure.tone }]),
+        ]);
     }
     #append(draft, settlement) {
         if (this.#nodes.length >= CONVERSATION_LIMITS.nodes) {
@@ -115,8 +135,10 @@ export class ConversationTree {
             messages: draft.messages,
             blocks: settledBlocks(draft.blocks),
             ...(draft.context === undefined ? {} : { context: draft.context }),
+            ...(draft.failure === undefined ? {} : { failure: draft.failure }),
         });
         assertTurn(node);
+        assertPersistableNode(node);
         const nodes = [...this.#nodes, node];
         assertBounds(nodes);
         return new ConversationTree(nodes, node.id);
@@ -135,8 +157,10 @@ export class ConversationTree {
             messages: draft.messages,
             blocks: settledBlocks(draft.blocks),
             context: draft.context ?? current.context,
+            failure: draft.failure,
         });
         assertTurn(node);
+        assertPersistableNode(node);
         const nodes = [...this.#nodes];
         nodes[id - 1] = node;
         assertBounds(nodes);
@@ -163,6 +187,7 @@ function ownedNode(node) {
         messages: Object.freeze(clone(node.messages)),
         blocks: Object.freeze(clone(node.blocks)),
         ...(node.context === undefined ? {} : { context: Object.freeze({ ...node.context }) }),
+        ...(node.failure === undefined ? {} : { failure: Object.freeze({ ...node.failure }) }),
     });
 }
 function settledBlocks(blocks) {
@@ -174,6 +199,8 @@ function settledBlocks(blocks) {
             return [settled];
         }
         if (block.kind === "tool") {
+            if (block.tone === "pending")
+                return [];
             const { startedAt: _startedAt, expanded: _expanded, ...settled } = block;
             return [settled];
         }
@@ -185,16 +212,26 @@ function assertTurn(node) {
         !validNodeId(node.parentId) || node.parentId >= node.id ||
         !Number.isSafeInteger(node.revision) || node.revision < 1 ||
         node.createdAt.length === 0 || node.createdAt.length > 64 ||
-        (node.settlement !== "checkpointed" && node.settlement !== "completed") ||
+        !validSettlement(node.settlement) ||
         node.messages.length < 2 || node.messages[0]?.role !== "user" ||
         node.identity.providerId.length === 0 || node.identity.providerId.length > 128 ||
         node.identity.model.length === 0 || node.identity.model.length > 512 ||
         node.identity.effort.length === 0 || node.identity.effort.length > 32)
         throw new Error("turn checkpoint is invalid");
-    if (node.settlement === "completed" && node.messages.at(-1)?.role !== "assistant") {
-        throw new Error("a completed turn must end with an assistant message");
+    if (node.settlement !== "checkpointed" && node.messages.at(-1)?.role !== "assistant") {
+        throw new Error("a resumable turn must end with an assistant message");
+    }
+    const failed = node.settlement === "failed" || node.settlement === "interrupted";
+    if (failed !== (node.failure !== undefined) ||
+        (node.settlement === "failed" && node.failure?.tone !== "error") ||
+        (node.settlement === "interrupted" && node.failure?.tone !== "warn")) {
+        throw new Error("turn failure state is invalid");
     }
 }
+function validSettlement(value) {
+    return value === "checkpointed" || value === "completed" ||
+        value === "failed" || value === "interrupted";
+}
 function assertBounds(nodes) {
     let messageCodeUnits = 0;
     let transcriptCodeUnits = 0;

package/dist/sessions/codec.js

@@ -1,17 +1,21 @@
 // Strict codecs for session files. Disk is an untrusted boundary even when
 // the directory is owner-only: every value is bounded and re-owned before it
 // can become conversation or provider input.
+import { Buffer } from "node:buffer";
 import { CONTEXT_LIMITS } from "../context/projection.js";
-export const SESSION_SCHEMA = 2;
+export const SESSION_SCHEMA = 3;
 export const SESSION_FILE_LIMITS = Object.freeze({
     text: 1_048_576,
+    metadataBytes: 64 * 1_024,
+    nodeBytes: 20 * 1_024 * 1_024,
     jsonDepth: 24,
     jsonNodes: 32_768,
     blocks: 8_192,
     details: 8_192,
 });
 export function encodeMeta(meta) {
-    return line(meta);
+    decodeMeta(meta);
+    return boundedLine(meta, SESSION_FILE_LIMITS.metadataBytes);
 }
 export function decodeMeta(value) {
     if (!record(value) || !keys(value, "createdAt,id,version,workspaceDigest,workspaceRoot")) {
@@ -32,7 +36,8 @@ export function decodeMeta(value) {
     });
 }
 export function encodeHead(head) {
-    return line(head);
+    decodeHead(head);
+    return boundedLine(head, SESSION_FILE_LIMITS.metadataBytes);
 }
 export function decodeHead(value) {
     if (!record(value) || !keys(value, "nodeId,parentId,revision,sequence,updatedAt,version")) {
@@ -55,7 +60,16 @@ export function decodeHead(value) {
     });
 }
 export function encodeNode(node, sequence, updatedAt) {
-    return line({
+    const envelope = nodeEnvelope(node, sequence, updatedAt);
+    decodeNode(envelope);
+    return boundedLine(envelope, SESSION_FILE_LIMITS.nodeBytes);
+}
+/** Enforce the exact current-disk boundary before a turn enters the tree. */
+export function assertPersistableNode(node) {
+    encodeNode(node, 1, node.createdAt);
+}
+function nodeEnvelope(node, sequence, updatedAt) {
+    return {
         version: SESSION_SCHEMA,
         sequence,
         updatedAt,
@@ -69,8 +83,9 @@ export function encodeNode(node, sequence, updatedAt) {
             messages: node.messages.map(messageRecord),
             blocks: node.blocks.flatMap(blockRecord),
             context: node.context ?? null,
+            failure: node.failure ?? null,
         },
-    });
+    };
 }
 export function decodeNode(value) {
     if (!record(value) || !keys(value, "node,sequence,updatedAt,version"))
@@ -82,7 +97,9 @@ export function decodeNode(value) {
     const raw = value["node"];
     const nodeKeys = version === 1
         ? "blocks,createdAt,id,identity,messages,parentId,revision,settlement"
-        : "blocks,context,createdAt,id,identity,messages,parentId,revision,settlement";
+        : version === 2
+            ? "blocks,context,createdAt,id,identity,messages,parentId,revision,settlement"
+            : "blocks,context,createdAt,failure,id,identity,messages,parentId,revision,settlement";
     if (!record(raw) || !keys(raw, nodeKeys)) {
         throw invalid();
     }
@@ -93,7 +110,7 @@ export function decodeNode(value) {
         !integer(raw["parentId"], 0) ||
         !integer(raw["revision"], 1) ||
         !timestamp(raw["createdAt"]) ||
-        (raw["settlement"] !== "checkpointed" && raw["settlement"] !== "completed") ||
+        !settlement(raw["settlement"], version) ||
         !record(identity) || !keys(identity, "effort,model,providerId") ||
         !bounded(identity["providerId"], 128) || !bounded(identity["model"], 512) ||
         !bounded(identity["effort"], 32) ||
@@ -103,6 +120,9 @@ export function decodeNode(value) {
     const context = version === 1
         ? undefined
         : contextFromRecord(raw["context"], raw["id"], messages.length);
+    const failure = version < 3
+        ? undefined
+        : failureFromRecord(raw["failure"], raw["settlement"]);
     const node = Object.freeze({
         id: raw["id"],
         parentId: raw["parentId"],
@@ -117,9 +137,25 @@ export function decodeNode(value) {
         messages: Object.freeze(messages.map(messageFromRecord)),
         blocks: Object.freeze(blocks.map(blockFromRecord)),
         ...(context === undefined ? {} : { context: Object.freeze(context) }),
+        ...(failure === undefined ? {} : { failure: Object.freeze(failure) }),
     });
     return Object.freeze({ sequence: value["sequence"], updatedAt: value["updatedAt"], node });
 }
+function failureFromRecord(value, settlement) {
+    const failed = settlement === "failed" || settlement === "interrupted";
+    if (value === null) {
+        if (failed)
+            throw invalid();
+        return undefined;
+    }
+    if (!failed || !record(value) || !keys(value, "text,tone"))
+        throw invalid();
+    if (!bounded(value["text"]) ||
+        (settlement === "failed" && value["tone"] !== "error") ||
+        (settlement === "interrupted" && value["tone"] !== "warn"))
+        throw invalid();
+    return { text: value["text"], tone: value["tone"] };
+}
 function contextFromRecord(value, ownerId, ownerMessages) {
     if (value === null)
         return undefined;
@@ -340,6 +376,12 @@ function jsonValue(value, budget, depth) {
 function line(value) {
     return `${JSON.stringify(value, null, 2)}\n`;
 }
+function boundedLine(value, maxBytes) {
+    const encoded = line(value);
+    if (Buffer.byteLength(encoded, "utf8") > maxBytes)
+        throw invalid();
+    return encoded;
+}
 function keys(value, expected) {
     return Object.keys(value).sort().join(",") === expected;
 }
@@ -356,7 +398,11 @@ function integer(value, minimum) {
     return typeof value === "number" && Number.isSafeInteger(value) && value >= minimum;
 }
 function schema(value) {
-    return value === 1 || value === SESSION_SCHEMA;
+    return value === 1 || value === 2 || value === SESSION_SCHEMA;
+}
+function settlement(value, version) {
+    return value === "checkpointed" || value === "completed" ||
+        (version >= 3 && (value === "failed" || value === "interrupted"));
 }
 function nullableInteger(value, minimum) {
     return value === null || integer(value, minimum);

package/dist/sessions/runtime.js

@@ -21,9 +21,9 @@ export class SessionPersistence {
         const lease = await store.claim(id);
         try {
             const snapshot = await store.load(id);
-            const conversation = snapshot.conversation.latestCompleted();
+            const conversation = snapshot.conversation.latestResumable();
             if (conversation === undefined)
-                throw new Error("session has no completed turn to resume");
+                throw new Error("session has no resumable turn");
             return Object.freeze({
                 conversation,
                 persistence: new SessionPersistence(store, id, lease),

package/dist/sessions/store.js

@@ -4,17 +4,17 @@
 // 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, readFile, readdir, realpath, rename, rm, stat, } from "node:fs/promises";
+import { chmod, lstat, mkdir, open, opendir, readFile, readdir, realpath, rename, rm, stat, } from "node:fs/promises";
 import * as path from "node:path";
 import { atomicWrite } from "../atomic.js";
 import { CONVERSATION_LIMITS, ConversationTree } from "../conversation.js";
 import { userDataPath } from "../user-data.js";
-import { decodeHead, decodeMeta, decodeNode, encodeHead, encodeMeta, encodeNode, SESSION_SCHEMA, } from "./codec.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;
 const FILE_MODE = 0o600;
-const MAX_CATALOG_SCAN = 128;
-const MAX_JSON_BYTES = 20 * 1024 * 1024;
+const MAX_CATALOG_ENTRIES = 4_096;
+const CATALOG_READ_CONCURRENCY = 8;
 const SESSION_NAME = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/;
 const NODE_NAME = /^(\d{6})\.json$/;
 const ATOMIC_NODE_TEMP = /^\.\d{6}\.json\.\d+\.[a-f0-9-]+\.tmp$/;
@@ -37,45 +37,45 @@ export class DurableSessionStore {
         if (!Number.isSafeInteger(limit) || limit < 1 || limit > 64) {
             throw new Error("session catalogue limit is invalid");
         }
-        const entries = await directoryEntries(this.#bucket);
-        const names = entries
-            .filter((entry) => entry.isDirectory() && SESSION_NAME.test(entry.name))
-            .map((entry) => entry.name)
-            .sort((left, right) => right.localeCompare(left))
-            .slice(0, MAX_CATALOG_SCAN);
+        const names = await catalogNames(this.#bucket);
         const catalog = [];
-        for (const id of names) {
-            try {
-                const snapshot = await this.load(id);
-                const conversation = snapshot.conversation.latestCompleted();
-                if (conversation === undefined)
-                    continue;
-                catalog.push({
-                    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.
-            }
+        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;
+                }
+            }));
+            catalog.push(...batch.filter((entry) => entry !== undefined));
         }
         return catalog
-            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
+            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt) || right.id.localeCompare(left.id))
             .slice(0, limit);
     }
     async load(id) {
         assertSessionId(id);
         const directory = this.#sessionDirectory(id);
         await assertDirectory(directory);
-        const meta = decodeMeta(await readJson(path.join(directory, "meta.json"), 64 * 1024));
+        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");
-        let head = decodeHead(await readJson(path.join(directory, "head.json"), 64 * 1024));
+        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);
         if (ahead.some((entry) => entry.sequence !== head.sequence + 1) || ahead.length > 1) {
@@ -242,6 +242,28 @@ export class DurableSessionStore {
         return owner !== undefined && pidIsAlive(owner.pid);
     }
 }
+async function catalogNames(directory) {
+    try {
+        await assertDirectory(directory);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    const names = [];
+    let entries = 0;
+    const handle = await opendir(directory);
+    for await (const entry of handle) {
+        entries++;
+        if (entries > MAX_CATALOG_ENTRIES) {
+            throw new Error(`session catalogue exceeds ${MAX_CATALOG_ENTRIES} entries`);
+        }
+        if (entry.isDirectory() && SESSION_NAME.test(entry.name))
+            names.push(entry.name);
+    }
+    return names.sort((left, right) => right.localeCompare(left));
+}
 function assertSharedNodes(previous, next, replacedId) {
     for (const node of previous.nodes) {
         if (node.id === replacedId)
@@ -278,7 +300,7 @@ async function readNodes(directory) {
         const id = Number(NODE_NAME.exec(name)?.[1]);
         if (id !== index + 1)
             throw new Error("session conversation nodes are not contiguous");
-        const decoded = decodeNode(await readJson(path.join(directory, name), MAX_JSON_BYTES));
+        const decoded = decodeNode(await readJson(path.join(directory, name), SESSION_FILE_LIMITS.nodeBytes));
         if (decoded.node.id !== id || sequences.has(decoded.sequence)) {
             throw new Error("session conversation node identity is invalid");
         }

package/dist/timeline.js

@@ -7,7 +7,7 @@ import { usageFromHistory } from "./usage.js";
 import { heading } from "./tui/picker.js";
 export function timelinePicker(conversation, palette) {
     const entries = timelineEntries(conversation);
-    const selectedId = conversation.latestCompleted()?.activeNodeId ?? 0;
+    const selectedId = conversation.latestResumable()?.activeNodeId ?? 0;
     const index = Math.max(0, entries.findIndex((entry) => entry.node.id === selectedId));
     return Object.freeze({
         picker: {
@@ -18,7 +18,7 @@ export function timelinePicker(conversation, palette) {
             options: entries.map((entry) => ({
                 label: `${entry.prefix}${preview(entry.node)}`,
                 hint: stamp(entry.node.createdAt),
-                ...(entry.node.id === selectedId ? { value: "active" } : {}),
+                ...timelineValue(entry.node, selectedId),
             })),
             index,
         },
@@ -38,12 +38,12 @@ export async function selectTimeline(session, choose) {
     return true;
 }
 function timelineEntries(conversation) {
-    const completed = conversation.nodes.filter((node) => node.settlement === "completed");
-    const completedIds = new Set(completed.map((node) => node.id));
+    const resumable = conversation.nodes.filter((node) => node.settlement !== "checkpointed");
+    const resumableIds = new Set(resumable.map((node) => node.id));
     const children = new Map();
-    for (const node of completed) {
+    for (const node of resumable) {
         let parentId = node.parentId;
-        while (parentId !== 0 && !completedIds.has(parentId)) {
+        while (parentId !== 0 && !resumableIds.has(parentId)) {
             parentId = conversation.node(parentId)?.parentId ?? 0;
         }
         const siblings = children.get(parentId) ?? [];
@@ -70,6 +70,12 @@ function timelineEntries(conversation) {
     visit(0, []);
     return entries;
 }
+function timelineValue(node, selectedId) {
+    const state = node.settlement === "completed" ? undefined : node.settlement;
+    const active = node.id === selectedId ? "active" : undefined;
+    const value = [state, active].filter((part) => part !== undefined).join(" · ");
+    return value === "" ? {} : { value };
+}
 function preview(node) {
     for (const message of node.messages) {
         if (message.role !== "user")

package/dist/tui/app-workflows.js

@@ -10,6 +10,7 @@ import { saveTranscript } from "../transcript-export.js";
 import { recordAuxiliaryUsage, recordUsage } from "../usage.js";
 import { selectTimeline } from "../timeline.js";
 import { answerAt } from "./approve.js";
+import * as edit from "./editor.js";
 import { cancel as cancelOpen } from "./overlay.js";
 import { controllerOptions, turnFailure } from "./session-view.js";
 import { transcribe } from "./turn.js";
@@ -136,7 +137,7 @@ export function appWorkflows(options) {
             },
             usage: (usage) => recordUsage(session.usage, usage),
         });
-        const persist = async (checkpoint, settlement) => {
+        const persist = async (checkpoint, settlement, failure) => {
             const next = session.conversation.commit({
                 ...(nodeId === undefined ? {} : { nodeId }),
                 parentId,
@@ -149,6 +150,7 @@ export function appWorkflows(options) {
                 messages: checkpoint.slice(historyStart),
                 blocks: state.blocks.slice(blockStart),
                 ...(context === undefined ? {} : { context }),
+                ...(failure === undefined ? {} : { failure }),
             }, settlement);
             await session.persistence?.checkpoint(next);
             session.conversation = next;
@@ -217,18 +219,65 @@ export function appWorkflows(options) {
             return compacted;
         };
         let finishReason;
+        let failed;
         try {
             await runTurn(history, controllerOptions(session, permissions.availableTools()), events, activity.control.signal, modelHistory);
         }
         catch (error) {
             const interrupted = activity.control.signal.aborted;
-            finishReason = interrupted ? "interrupted" : "failed";
-            options.emit(turnFailure(session, error, interrupted));
+            const completed = nodeId !== undefined && session.conversation.activeNodeId === nodeId &&
+                session.conversation.activeNode?.settlement === "completed";
+            if (completed) {
+                const notice = turnFailure(session, error, interrupted);
+                feedback.show({ text: notice.text, tone: notice.tone, timeoutMs: 6_000 });
+            }
+            else {
+                finishReason = interrupted ? "interrupted" : "failed";
+                failed = { error: error, interrupted };
+            }
         }
         finally {
-            events.finish(finishReason);
-            options.finishActivity(activity);
+            try {
+                events.finish(finishReason);
+                if (failed !== undefined) {
+                    const notice = turnFailure(session, failed.error, failed.interrupted);
+                    const settlement = failed.interrupted ? "interrupted" : "failed";
+                    const failure = {
+                        text: notice.text,
+                        tone: failed.interrupted ? "warn" : "error",
+                    };
+                    options.emit(notice);
+                    try {
+                        await persist(closeFailedTurn(history, settlement), settlement, failure);
+                    }
+                    catch (error) {
+                        // A failed persistence boundary cannot remain visible as if it had
+                        // been saved. Revert to the last durable path and return the input
+                        // to the composer so the user can retry without losing it.
+                        options.replaceTranscript();
+                        state.editor = edit.of(text);
+                        feedback.show({
+                            text: error.message,
+                            tone: "error",
+                            timeoutMs: 6_000,
+                        });
+                    }
+                }
+            }
+            finally {
+                options.finishActivity(activity);
+            }
         }
     }
     return { command, turn };
 }
+function closeFailedTurn(history, settlement) {
+    const closed = [...history];
+    if (closed.at(-1)?.role === "assistant")
+        return closed;
+    const text = settlement === "interrupted"
+        ? "The previous attempt was interrupted by the user before completion."
+        : "The previous attempt failed before completion.";
+    closed.push({ role: "assistant", content: [{ kind: "text", text }] });
+    return closed;
+}

package/dist/tui/app.js

@@ -41,6 +41,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     let stopResize = () => { };
     let stopInput = () => { };
     let failure;
+    let activeWorkflow;
     // Timers outlive the teardown they were scheduled before. Painting after the
     // terminal has been handed back would write escapes into the user's shell.
     let live = true;
@@ -141,22 +142,42 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         if (!live)
             return;
         live = false;
-        stopInput();
-        stopResize();
+        safely(stopInput);
+        safely(stopResize);
         if (spinTimer !== undefined)
             clearInterval(spinTimer);
         if (frameTimer !== undefined)
             clearTimeout(frameTimer);
         if (escapeTimer !== undefined)
             clearTimeout(escapeTimer);
-        feedback.close();
-        terminal.leave();
+        safely(() => feedback.close());
+        safely(() => terminal.leave());
         closed?.();
     }
+    function safely(action) {
+        try {
+            action();
+        }
+        catch (error) {
+            failure ??= { error };
+        }
+    }
     function fail(error) {
         failure ??= { error };
+        state.open = overlay.cancel(state.open);
+        state.activity?.control.abort(error);
         quit();
     }
+    function track(work) {
+        const tracked = work
+            .catch((error) => fail(error))
+            .finally(() => {
+            if (activeWorkflow === tracked)
+                activeWorkflow = undefined;
+        });
+        activeWorkflow = tracked;
+        return tracked;
+    }
     function requestQuit() {
         const activity = state.activity;
         if (activity === undefined) {
@@ -226,7 +247,10 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         session,
         state,
         feedback,
-        actions,
+        actions: {
+            command: (text) => track(actions.command(text)),
+            turn: (text) => track(actions.turn(text)),
+        },
         live: () => live,
         quit,
         requestQuit,
@@ -236,7 +260,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     });
     const resumeAtLaunch = session.resume === undefined
         ? undefined
-        : openResumedSession(session.resume);
+        : track(openResumedSession(session.resume));
     async function openResumedSession(launch) {
         while (live) {
             const index = await new Promise((resolve) => {
@@ -305,6 +329,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     finally {
         try {
             quit();
+            await activeWorkflow;
         }
         finally {
             await session.persistence?.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@giovannijecha/jecode",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "An owned coding agent with zero external runtime dependencies.",
   "license": "MIT",
   "repository": {