@giovannijecha/jecode 0.4.0 → 0.6.0

package/dist/sessions/store.js

@@ -0,0 +1,368 @@
+// Durable, workspace-scoped conversation storage.
+//
+// Each node is its own atomically replaced file. The head is advanced only
+// 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 * 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 { 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 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$/;
+export class DurableSessionStore {
+    workspaceRoot;
+    workspaceDigest;
+    #sessionsRoot;
+    #bucket;
+    constructor(workspaceRoot, sessionsRoot) {
+        this.workspaceRoot = workspaceRoot;
+        this.workspaceDigest = digestWorkspace(workspaceRoot);
+        this.#sessionsRoot = sessionsRoot;
+        this.#bucket = path.join(sessionsRoot, this.workspaceDigest);
+    }
+    static async open(workspaceRoot, sessionsRoot = userDataPath("sessions")) {
+        const canonical = await realpath(path.resolve(workspaceRoot));
+        return new DurableSessionStore(canonical, path.resolve(sessionsRoot));
+    }
+    async list(limit = 32) {
+        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 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.
+            }
+        }
+        return catalog
+            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
+            .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));
+        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));
+        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) {
+            throw new Error("session has an ambiguous incomplete checkpoint");
+        }
+        const byId = new Map(stored.map((entry) => [entry.node.id, entry]));
+        const headed = byId.get(head.nodeId);
+        if (headed === undefined)
+            throw new Error("session head is missing its conversation node");
+        if (ahead.length === 0) {
+            if (headed.sequence !== head.sequence || headed.node.revision !== head.revision ||
+                headed.node.parentId !== head.parentId) {
+                throw new Error("session head does not match its conversation node");
+            }
+        }
+        else {
+            const candidate = ahead[0];
+            const replacesHead = candidate.node.id === head.nodeId &&
+                candidate.node.parentId === head.parentId &&
+                candidate.node.revision === head.revision + 1;
+            const candidateParent = byId.get(candidate.node.parentId);
+            const extendsTree = candidate.node.id === stored.length &&
+                candidate.node.revision === 1 && candidateParent !== undefined &&
+                candidateParent.sequence <= head.sequence;
+            if (!replacesHead && !extendsTree) {
+                throw new Error("session checkpoint cannot be recovered safely");
+            }
+            head = {
+                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 });
+        }
+        const nodes = stored.map((entry) => entry.node);
+        const conversation = ConversationTree.restore(nodes, head.nodeId);
+        return Object.freeze({ meta, head, conversation });
+    }
+    async publish(conversation, claim) {
+        const active = conversation.activeNode;
+        if (active === undefined)
+            throw new Error("an empty conversation cannot be persisted");
+        await this.#ensureBucket();
+        const now = new Date().toISOString();
+        const id = sessionId(now);
+        const token = claim === true ? leaseToken() : undefined;
+        const temporary = path.join(this.#bucket, `.${id}.${randomUUID()}.tmp`);
+        const target = this.#sessionDirectory(id);
+        const meta = {
+            version: SESSION_SCHEMA,
+            id,
+            workspaceRoot: this.workspaceRoot,
+            workspaceDigest: this.workspaceDigest,
+            createdAt: now,
+        };
+        const head = {
+            version: SESSION_SCHEMA,
+            sequence: conversation.nodes.length,
+            nodeId: active.id,
+            parentId: active.parentId,
+            revision: active.revision,
+            updatedAt: now,
+        };
+        try {
+            await makePrivateDirectory(temporary);
+            const nodes = path.join(temporary, "nodes");
+            await makePrivateDirectory(nodes);
+            for (let index = 0; index < conversation.nodes.length; index++) {
+                const node = conversation.nodes[index];
+                await atomicWrite(path.join(nodes, nodeName(node.id)), encodeNode(node, index + 1, now), { mode: FILE_MODE });
+            }
+            await atomicWrite(path.join(temporary, "meta.json"), encodeMeta(meta), { mode: FILE_MODE });
+            await atomicWrite(path.join(temporary, "head.json"), encodeHead(head), { mode: FILE_MODE });
+            if (token !== undefined) {
+                await atomicWrite(path.join(temporary, "active"), token, { mode: FILE_MODE });
+            }
+            await rename(temporary, target);
+        }
+        catch (error) {
+            await removeTemporaryDirectory(temporary, this.#bucket);
+            throw error;
+        }
+        const snapshot = Object.freeze({ meta, head, conversation });
+        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);
+        const active = conversation.activeNode;
+        if (active === undefined)
+            throw new Error("an empty conversation cannot be checkpointed");
+        if (sameNode(active, previous.conversation.activeNode)) {
+            return Object.freeze({ ...previous, conversation });
+        }
+        const replacesHead = active.id === previous.head.nodeId &&
+            active.revision === previous.head.revision + 1 &&
+            conversation.nodes.length === previous.conversation.nodes.length;
+        const extendsTree = active.id === previous.conversation.nodes.length + 1 &&
+            previous.conversation.node(active.parentId) !== undefined && active.revision === 1 &&
+            conversation.nodes.length === previous.conversation.nodes.length + 1;
+        if (!replacesHead && !extendsTree) {
+            throw new Error("session checkpoint does not extend its durable tree");
+        }
+        assertSharedNodes(previous.conversation, conversation, replacesHead ? active.id : undefined);
+        const now = new Date().toISOString();
+        const head = {
+            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 });
+    }
+    async claim(id) {
+        assertSessionId(id);
+        await assertDirectory(this.#sessionDirectory(id));
+        const file = path.join(this.#sessionDirectory(id), "active");
+        const token = leaseToken();
+        for (let attempt = 0; attempt < 2; attempt++) {
+            try {
+                const handle = await open(file, "wx", FILE_MODE);
+                try {
+                    await handle.writeFile(token, "utf8");
+                    await handle.sync();
+                }
+                finally {
+                    await handle.close();
+                }
+                return sessionLease(id, file, token);
+            }
+            catch (error) {
+                if (error.code !== "EEXIST")
+                    throw error;
+                const owner = await leaseOwner(file);
+                if (owner !== undefined && pidIsAlive(owner.pid)) {
+                    throw new Error("session is already open in another Jecode process");
+                }
+                if (owner !== undefined) {
+                    await removeLease(file, owner.token);
+                }
+            }
+        }
+        throw new Error("session could not be claimed");
+    }
+    #sessionDirectory(id) {
+        return path.join(this.#bucket, id);
+    }
+    async #ensureBucket() {
+        await makePrivateDirectory(this.#sessionsRoot);
+        await makePrivateDirectory(this.#bucket);
+    }
+    async #leaseIsActive(id) {
+        const owner = await leaseOwner(path.join(this.#sessionDirectory(id), "active"));
+        return owner !== undefined && pidIsAlive(owner.pid);
+    }
+}
+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)) {
+            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 sameNode(left, right) {
+    return right !== undefined && normalizedNode(left) === normalizedNode(right);
+}
+async function readNodes(directory) {
+    await assertDirectory(directory);
+    const entries = await readdir(directory, { withFileTypes: true });
+    const names = entries.filter((entry) => entry.isFile() && NODE_NAME.test(entry.name))
+        .map((entry) => entry.name).sort();
+    if (names.length === 0 || names.length > CONVERSATION_LIMITS.nodes) {
+        throw new Error("session has an invalid conversation size");
+    }
+    if (entries.length > CONVERSATION_LIMITS.nodes + 64 ||
+        entries.some((entry) => !entry.isFile() || (!NODE_NAME.test(entry.name) && !ATOMIC_NODE_TEMP.test(entry.name)))) {
+        throw new Error("session node directory contains unsupported data");
+    }
+    const stored = [];
+    const sequences = new Set();
+    for (let index = 0; index < names.length; index++) {
+        const name = names[index];
+        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));
+        if (decoded.node.id !== id || sequences.has(decoded.sequence)) {
+            throw new Error("session conversation node identity is invalid");
+        }
+        sequences.add(decoded.sequence);
+        stored.push(decoded);
+    }
+    return stored;
+}
+async function readJson(file, limit) {
+    const details = await lstat(file);
+    if (details.isSymbolicLink() || !details.isFile() || details.size > limit) {
+        throw new Error("session file is unsafe or too large");
+    }
+    try {
+        return JSON.parse(await readFile(file, "utf8"));
+    }
+    catch {
+        throw new Error("session file is not valid JSON");
+    }
+}
+async function assertDirectory(directory) {
+    const details = await lstat(directory);
+    if (details.isSymbolicLink() || !details.isDirectory()) {
+        throw new Error("session path is not a direct directory");
+    }
+}
+async function makePrivateDirectory(directory) {
+    await mkdir(directory, { recursive: true, mode: DIRECTORY_MODE });
+    await assertDirectory(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) ||
+        !path.basename(directory).startsWith(".") || !path.basename(directory).endsWith(".tmp"))
+        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 text.slice(0, 160);
+    }
+    return "Untitled session";
+}
+function nodeName(id) {
+    return `${String(id).padStart(6, "0")}.json`;
+}
+function sessionId(now) {
+    return `${now.replace(/[-:.]/g, "").replace("Z", "Z")}-${randomUUID()}`;
+}
+function digestWorkspace(workspaceRoot) {
+    return createHash("sha256").update(workspaceKey(workspaceRoot)).digest("hex");
+}
+function workspaceKey(workspaceRoot) {
+    const normalized = path.normalize(workspaceRoot);
+    return process.platform === "win32" ? normalized.toLocaleLowerCase("en-US") : normalized;
+}
+function assertSessionId(id) {
+    if (!SESSION_NAME.test(id))
+        throw new Error("session id is invalid");
+}

package/dist/settings-command.js

@@ -1,6 +1,7 @@
 // The persistent settings hub. Provider access and model selection reuse the
 // same command flows exposed directly through /providers and /models.
 import { saveCommandSettings } from "./command-settings.js";
+import { MAX_COMPACTION_PERCENT, MIN_COMPACTION_PERCENT } from "./context/policy.js";
 import { modelsCommand } from "./model-command.js";
 import { providerFailure } from "./provider-errors.js";
 import { providerLabel } from "./provider-label.js";
@@ -43,6 +44,9 @@ export async function settingsCommand(session, host) {
             case "maxSteps":
                 await numberSetting(session, host, "maxSteps", "max tool steps");
                 break;
+            case "compactionPercent":
+                await compactionSetting(session, host);
+                break;
             case "reducedMotion":
                 await motionSetting(session, host);
                 break;
@@ -53,9 +57,11 @@ export async function settingsCommand(session, host) {
     }
 }
 export function settingsPicker(values, index = 0) {
+    const items = settingsItems(values);
     return {
         title: [],
-        options: settingsItems(values).map((item) => item.option),
+        options: items.map((item) => item.option),
+        visible: items.length,
         index,
     };
 }
@@ -76,13 +82,17 @@ function settingsItems(values) {
                     option: { label: "max output tokens", value: String(values.maxTokens) },
                 }]),
         { action: "maxSteps", option: { label: "max tool steps", value: String(values.maxSteps) } },
+        {
+            action: "compactionPercent",
+            option: { label: "context compaction", value: `${values.compactionPercent}%` },
+        },
         {
             action: "reducedMotion",
             option: { label: "reduced motion", value: values.reducedMotion ? "on" : "off" },
         },
         {
             action: "providers",
-            option: { label: "providers", hint: "manage access and connections" },
+            option: { label: "providers", hint: "manage connections" },
         },
     ];
 }
@@ -93,6 +103,7 @@ function settingsValues(session) {
         effort: session.config.effort,
         ...(session.provider.id === "openai-codex" ? {} : { maxTokens: session.config.maxTokens }),
         maxSteps: session.config.maxSteps,
+        compactionPercent: session.config.compactionPercent,
         reducedMotion: session.config.reducedMotion,
     };
 }
@@ -185,6 +196,35 @@ async function numberSetting(session, host, name, label) {
         return;
     session.config[name] = value;
 }
+async function compactionSetting(session, host) {
+    if (host.type === undefined)
+        return;
+    const label = "context compaction";
+    const field = {
+        title: heading(label, `${MIN_COMPACTION_PERCENT}-${MAX_COMPACTION_PERCENT} percent`, session.palette),
+        right: "enter save · esc back",
+        editor: of(String(session.config.compactionPercent)),
+        secret: false,
+        note: "Compacts when model context reaches this percentage.",
+    };
+    const text = await host.type(field);
+    if (text === undefined)
+        return;
+    const value = Number(text);
+    if (!Number.isSafeInteger(value) ||
+        value < MIN_COMPACTION_PERCENT ||
+        value > MAX_COMPACTION_PERCENT) {
+        host.emit({
+            kind: "notice",
+            text: `${label} must be from ${MIN_COMPACTION_PERCENT} to ${MAX_COMPACTION_PERCENT}`,
+            tone: "error",
+        });
+        return;
+    }
+    if (!(await saveCommandSettings(host, { compactionPercent: value })))
+        return;
+    session.config.compactionPercent = value;
+}
 function chooser(host) {
     if (host.choose === undefined) {
         host.emit({ kind: "notice", text: "that command needs the screen", tone: "warn" });

package/dist/settings.js

@@ -3,6 +3,7 @@ import { readFileSync } from "node:fs";
 import { chmod, mkdir } from "node:fs/promises";
 import * as path from "node:path";
 import { atomicWrite } from "./atomic.js";
+import { MAX_COMPACTION_PERCENT, MIN_COMPACTION_PERCENT } from "./context/policy.js";
 import { EFFORTS } from "./effort.js";
 import { providerNames } from "./providers/index.js";
 import { parseOllamaEndpoint } from "./providers/ollama-endpoint.js";
@@ -59,6 +60,7 @@ function normalize(value) {
     const reducedMotion = typeof value["reducedMotion"] === "boolean" ? value["reducedMotion"] : undefined;
     const maxTokens = positiveInteger(value["maxTokens"]);
     const maxSteps = positiveInteger(value["maxSteps"]);
+    const compactionPercent = percentage(value["compactionPercent"]);
     return {
         ...(provider === undefined ? {} : { provider }),
         ...(models === undefined ? {} : { models }),
@@ -67,6 +69,7 @@ function normalize(value) {
         ...(reducedMotion === undefined ? {} : { reducedMotion }),
         ...(maxTokens === undefined ? {} : { maxTokens }),
         ...(maxSteps === undefined ? {} : { maxSteps }),
+        ...(compactionPercent === undefined ? {} : { compactionPercent }),
     };
 }
 function modelsOf(value, providers) {
@@ -91,6 +94,12 @@ function endpoint(value) {
 function positiveInteger(value) {
     return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
 }
+function percentage(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) &&
+        value >= MIN_COMPACTION_PERCENT && value <= MAX_COMPACTION_PERCENT
+        ? value
+        : undefined;
+}
 function record(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/dist/start.js

@@ -3,12 +3,16 @@ import * as path from "node:path";
 import { runBatch } from "./batch.js";
 import { showCliInfo } from "./cli-info.js";
 import { loadConfig } from "./config.js";
+import { ConversationTree } from "./conversation.js";
+import { parseLaunch } from "./launch.js";
 import { systemPrompt } from "./prompt.js";
 import { configureProviders, selectProvider } from "./providers/index.js";
+import { SessionPersistence } from "./sessions/runtime.js";
+import { DurableSessionStore } from "./sessions/store.js";
 import { builtinTools } from "./tools/index.js";
 import { configureColor } from "./ui/render.js";
 import { STEEL } from "./ui/theme.js";
-import { emptyUsage } from "./usage.js";
+import { emptyUsage, usageFromHistory } from "./usage.js";
 import { runApp } from "./tui/app.js";
 import { interactive } from "./tui/screen.js";
 export async function start(args = process.argv.slice(2), environment = {}) {
@@ -17,10 +21,17 @@ export async function start(args = process.argv.slice(2), environment = {}) {
     const write = environment.write ?? ((text) => process.stdout.write(text));
     if (await showCliInfo(args, applicationRoot, write))
         return;
-    const config = loadConfig(args);
+    const launch = parseLaunch(args);
+    const config = loadConfig(launch.configArgs);
     configureProviders(config);
     const provider = selectProvider(config.providerId);
     const hasScreen = environment.interactive?.() ?? interactive();
+    if (launch.kind === "resume" && !hasScreen) {
+        throw new Error("resume needs an interactive terminal");
+    }
+    if (launch.kind === "resume" && config.ephemeral) {
+        throw new Error("--ephemeral cannot be combined with resume");
+    }
     // A provider whose catalogue is not fixed has no sensible default model.
     // The TUI can ask; a pipe cannot, so batch mode still requires one up front.
     const model = config.model === "" ? provider.defaultModel : config.model;
@@ -35,13 +46,65 @@ export async function start(args = process.argv.slice(2), environment = {}) {
         palette: STEEL,
         tools: builtinTools(),
         system: systemPrompt(config),
-        history: [],
+        conversation: ConversationTree.empty(),
         usage: emptyUsage(),
     };
     if (hasScreen) {
-        await (environment.runInteractive ?? runApp)(session, transcriptRoot);
+        if (!config.ephemeral) {
+            const store = await DurableSessionStore.open(config.root, environment.sessionsRoot);
+            if (launch.kind === "resume") {
+                const candidates = await SessionPersistence.candidates(store);
+                if (candidates.length === 0)
+                    throw new Error("no resumable sessions found for this workspace");
+                const open = async (id) => {
+                    const resumed = await SessionPersistence.resume(store, id);
+                    try {
+                        applyResumedSession(session, resumed.conversation, resumed.persistence);
+                    }
+                    catch (error) {
+                        await resumed.persistence.close();
+                        throw error;
+                    }
+                };
+                if (launch.latest)
+                    await open(candidates[0].id);
+                else
+                    session.resume = { candidates, open };
+            }
+            else {
+                session.persistence = SessionPersistence.fresh(store);
+            }
+        }
+        try {
+            await (environment.runInteractive ?? runApp)(session, transcriptRoot);
+        }
+        finally {
+            await session.persistence?.close();
+        }
     }
     else {
         await (environment.runNonInteractive ?? runBatch)(session);
     }
 }
+function applyResumedSession(session, conversation, persistence) {
+    const identity = conversation.activeNode?.identity;
+    if (identity === undefined)
+        throw new Error("resumed session has no active turn");
+    const provider = selectProvider(identity.providerId);
+    const config = {
+        ...session.config,
+        providerId: identity.providerId,
+        model: identity.model,
+        effort: identity.effort,
+    };
+    const system = systemPrompt(config);
+    const usage = usageFromHistory(conversation.history);
+    session.config = config;
+    session.provider = provider;
+    session.model = identity.model;
+    session.system = system;
+    session.conversation = conversation;
+    session.usage = usage;
+    session.persistence = persistence;
+    session.resume = undefined;
+}

package/dist/transcript-types.js

@@ -0,0 +1,6 @@
+// Provider-neutral transcript vocabulary.
+//
+// The conversation domain stores these settled semantic blocks so a resumed
+// session can rebuild the same screen without persisting terminal escape
+// sequences or renderer state.
+export {};

package/dist/tui/activity.js

@@ -9,3 +9,6 @@ export function elapsed(activity, now = Date.now()) {
     const minutes = Math.floor(seconds / 60);
     return `${minutes}m ${String(seconds % 60).padStart(2, "0")}s`;
 }
+export function activityStatus(activity, label = activity.label, now = Date.now()) {
+    return `${label} · ${elapsed(activity, now)}`;
+}

package/dist/tui/app-input.js

@@ -21,6 +21,15 @@ export function appInput(options) {
         }
         if (state.feedback !== undefined)
             feedback.dismiss();
+        // 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.
+        if (key.ctrl && key.name === "o") {
+            const changed = toggleDetails(state.blocks);
+            if (changed !== undefined)
+                options.transcriptChanged(changed);
+            return;
+        }
         if (state.open !== undefined) {
             const outcome = overlay.handle(state.open, key);
             state.open = outcome.open;
@@ -95,12 +104,6 @@ export function appInput(options) {
             options.invalidate();
             return;
         }
-        if (key.ctrl && key.name === "o") {
-            const changed = toggleDetails(state.blocks);
-            if (changed !== undefined)
-                options.transcriptChanged(changed);
-            return;
-        }
         const edited = applyKey(state.editor, key);
         if (edited !== undefined) {
             state.editor = edited;