@giovannijecha/jecode 0.5.0 → 0.7.0

package/dist/controller-request.js

@@ -0,0 +1,34 @@
+// One streamed provider request with a single safe context-overflow recovery.
+export async function requestAssistant(history, current, specs, options, events, signal) {
+    const prepared = await events.onContext?.(history, current, "budget");
+    let context = prepared === undefined ? [...current] : clone(prepared);
+    let recovered = false;
+    for (;;) {
+        try {
+            const message = await options.provider.send({
+                model: options.model,
+                system: options.system,
+                messages: context,
+                tools: specs,
+                maxTokens: options.maxTokens,
+                effort: options.effort,
+                signal,
+                onStream: (event) => events.onStream(event),
+                onStatus: (status) => events.onStatus?.(status),
+            });
+            return { message, context };
+        }
+        catch (error) {
+            if (recovered)
+                throw error;
+            const projected = await events.onContext?.(history, context, "overflow", error);
+            if (projected === undefined)
+                throw error;
+            context = clone(projected);
+            recovered = true;
+        }
+    }
+}
+function clone(messages) {
+    return structuredClone([...messages]);
+}

package/dist/controller.js

@@ -5,6 +5,7 @@
 // loop iterates. That constraint is implemented here, not left as a product claim.
 import { isToolCall } from "./types.js";
 import { findTool, runTool, toolSpecs } from "./tools/index.js";
+import { requestAssistant } from "./controller-request.js";
 export const MAX_TOOL_CALLS_PER_STEP = 32;
 /** Independent read calls share one bounded execution wave. */
 export const MAX_CONCURRENT_TOOL_CALLS = 4;
@@ -13,24 +14,27 @@ export const MAX_CONCURRENT_TOOL_CALLS = 4;
  * stops asking for tools. `history` is mutated in place, so an aborted turn
  * still leaves the conversation in a consistent state.
  */
-export async function runTurn(history, options, events, signal) {
+export async function runTurn(history, options, events, signal, modelHistory = history) {
     const specs = toolSpecs(options.tools);
+    let context = modelHistory;
+    const append = (message) => {
+        history.push(message);
+        if (context !== history)
+            context.push(message);
+    };
+    const checkpoint = async (settlement) => {
+        const projected = await events.onCheckpoint?.(history, settlement, context);
+        if (projected !== undefined)
+            context = clone([...projected]);
+    };
     for (let step = 0; step < options.maxSteps; step++) {
         throwIfAborted(signal);
         events.onStep?.(step + 1, options.maxSteps);
         // The message is displayed as it streams; what comes back here is the
         // assembled version, which exists to be appended to the history.
-        const assistant = await options.provider.send({
-            model: options.model,
-            system: options.system,
-            messages: history,
-            tools: specs,
-            maxTokens: options.maxTokens,
-            effort: options.effort,
-            signal,
-            onStream: (event) => events.onStream(event),
-            onStatus: (status) => events.onStatus?.(status),
-        });
+        const response = await requestAssistant(history, context, specs, options, events, signal);
+        const assistant = response.message;
+        context = response.context;
         throwIfAborted(signal);
         const calls = assistant.content.filter(isToolCall);
         if (assistant.content.length === 0) {
@@ -40,11 +44,11 @@ export async function runTurn(history, options, events, signal) {
             throw new Error(`provider returned ${calls.length} tool calls in one step (maximum ${MAX_TOOL_CALLS_PER_STEP})`);
         }
         assertToolCallIds(calls);
-        history.push(assistant);
+        append(assistant);
         if (calls.length === 0) {
             if (assistant.usage !== undefined)
                 events.onUsage?.(assistant.usage);
-            await events.onCheckpoint?.(history, "completed");
+            await checkpoint("completed");
             return; // the model is done — hand back to the user
         }
         // Consecutive shared reads run together. An exclusive call is an ordered
@@ -88,7 +92,7 @@ export async function runTurn(history, options, events, signal) {
                 repairs.push({ call, run });
                 results.push(run.result);
             }
-            history.push({ role: "user", content: results });
+            append({ role: "user", content: results });
             // History repair is the invariant. UI recovery is best-effort and must
             // never replace the original exception or leave the conversation open.
             for (const { call, run } of repairs) {
@@ -101,13 +105,13 @@ export async function runTurn(history, options, events, signal) {
                     // The surface is already failing; the next turn can still proceed.
                 }
             }
-            await events.onCheckpoint?.(history, "checkpointed");
+            await checkpoint("checkpointed");
             if (interrupted)
                 throw abortReason(signal);
             throw error;
         }
-        history.push({ role: "user", content: results });
-        await events.onCheckpoint?.(history, "checkpointed");
+        append({ role: "user", content: results });
+        await checkpoint("checkpointed");
     }
     throw new Error(`gave up after ${options.maxSteps} steps without finishing (raise --max-steps)`);
 }
@@ -190,3 +194,6 @@ function throwIfAborted(signal) {
 function abortReason(signal) {
     return signal.reason instanceof Error ? signal.reason : new Error("interrupted");
 }
+function clone(value) {
+    return structuredClone(value);
+}

package/dist/conversation.js

@@ -1,13 +1,15 @@
 // Canonical settled conversation state.
 //
 // A node owns one complete user-turn delta. The selected root-to-node path is
-// the only history sent to a provider and the only transcript shown by the
-// TUI. Provider traffic and live screen blocks remain prospective until the
-// controller reaches a consistent completion or tool checkpoint.
+// the durable source for the transcript and full history; context anchors can
+// 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";
 export const CONVERSATION_LIMITS = Object.freeze({
     nodes: 1_024,
     messageCodeUnits: 8_388_608,
     transcriptCodeUnits: 8_388_608,
+    contextCodeUnits: 8_388_608,
 });
 /** Immutable tree with one selected model/transcript path. */
 export class ConversationTree {
@@ -34,6 +36,7 @@ export class ConversationTree {
                 identity: node.identity,
                 messages: node.messages,
                 blocks: node.blocks,
+                ...(node.context === undefined ? {} : { context: node.context }),
             }, node.settlement);
             const restored = tree.activeNode;
             if (restored === undefined || restored.id !== node.id) {
@@ -92,6 +95,9 @@ export class ConversationTree {
     get history() {
         return this.#path().flatMap((node) => clone(node.messages));
     }
+    get contextHistory() {
+        return projectContext(this.#path());
+    }
     get transcript() {
         return this.#path().flatMap((node) => clone(node.blocks));
     }
@@ -108,6 +114,7 @@ export class ConversationTree {
             identity: draft.identity,
             messages: draft.messages,
             blocks: settledBlocks(draft.blocks),
+            ...(draft.context === undefined ? {} : { context: draft.context }),
         });
         assertTurn(node);
         const nodes = [...this.#nodes, node];
@@ -127,6 +134,7 @@ export class ConversationTree {
             identity: draft.identity,
             messages: draft.messages,
             blocks: settledBlocks(draft.blocks),
+            context: draft.context ?? current.context,
         });
         assertTurn(node);
         const nodes = [...this.#nodes];
@@ -154,6 +162,7 @@ function ownedNode(node) {
         identity: Object.freeze({ ...node.identity }),
         messages: Object.freeze(clone(node.messages)),
         blocks: Object.freeze(clone(node.blocks)),
+        ...(node.context === undefined ? {} : { context: Object.freeze({ ...node.context }) }),
     });
 }
 function settledBlocks(blocks) {
@@ -189,9 +198,13 @@ function assertTurn(node) {
 function assertBounds(nodes) {
     let messageCodeUnits = 0;
     let transcriptCodeUnits = 0;
+    let contextCodeUnits = 0;
     for (const node of nodes) {
         messageCodeUnits += JSON.stringify(node.messages).length;
         transcriptCodeUnits += JSON.stringify(node.blocks).length;
+        contextCodeUnits += node.context?.summary.length ?? 0;
+        if (node.context !== undefined)
+            assertContextPath(nodes, node);
     }
     if (messageCodeUnits > CONVERSATION_LIMITS.messageCodeUnits) {
         throw new Error("conversation model history reached its session limit — start /new");
@@ -199,6 +212,21 @@ function assertBounds(nodes) {
     if (transcriptCodeUnits > CONVERSATION_LIMITS.transcriptCodeUnits) {
         throw new Error("conversation transcript reached its session limit — start /new");
     }
+    if (contextCodeUnits > CONVERSATION_LIMITS.contextCodeUnits) {
+        throw new Error("conversation context summaries reached their session limit — start /new");
+    }
+}
+function assertContextPath(nodes, owner) {
+    const context = owner.context;
+    const boundary = nodes[context.throughNodeId - 1];
+    if (boundary === undefined || !validContextAnchor(context, boundary.messages.length)) {
+        throw new Error("turn context checkpoint is invalid");
+    }
+    let id = owner.id;
+    while (id !== 0 && id !== boundary.id)
+        id = nodes[id - 1]?.parentId ?? 0;
+    if (id !== boundary.id)
+        throw new Error("turn context checkpoint is outside its branch");
 }
 function validNodeId(value) {
     return Number.isSafeInteger(value) && value >= 0;

package/dist/providers/anthropic.js

@@ -7,7 +7,7 @@
 // purpose: the default omits the reasoning text, which on a screen reads as a
 // long silence before anything appears.
 import { postSse } from "./http.js";
-import { listModels } from "./catalog.js";
+import { modelCatalog } from "./catalog.js";
 import { keyFor } from "../credentials.js";
 import { EFFORTS, requireSupportedEffort } from "../effort.js";
 import { assembleAnthropic } from "./anthropic-stream.js";
@@ -19,6 +19,7 @@ const KEY = "ANTHROPIC_API_KEY";
 const ADAPTIVE = /^claude-(?:fable-5|mythos-(?:5|preview)|opus-(?:5|4-[678])|sonnet-(?:5|4-6))(?:-|$)/;
 const MAX_WITHOUT_XHIGH = ["low", "medium", "high", "max"];
 const ANTHROPIC_45_EFFORTS = ["low", "medium", "high"];
+let contextByModel = new Map();
 export function supportsAdaptiveThinking(model) {
     return ADAPTIVE.test(model);
 }
@@ -41,12 +42,24 @@ export const anthropic = {
     },
     // Newest first is how the endpoint already answers, so the order is left
     // exactly as it arrives rather than re-sorted into something less useful.
-    models(signal, onStatus) {
-        return listModels(MODELS, headers(requireKey()), signal, onStatus);
+    async models(signal, onStatus) {
+        const catalog = await loadModels(signal, onStatus);
+        contextByModel = catalog.contexts;
+        return catalog.ids;
     },
     async efforts(model) {
         return anthropicEfforts(model);
     },
+    async contextWindow(model, signal, onStatus) {
+        if (contextByModel.has(model))
+            return contextByModel.get(model);
+        const catalog = await loadModels(signal, onStatus);
+        contextByModel = catalog.contexts;
+        const context = contextByModel.get(model);
+        if (!contextByModel.has(model))
+            contextByModel.set(model, undefined);
+        return context;
+    },
     location: () => "cloud",
     async send(req) {
         const key = requireKey();
@@ -77,6 +90,23 @@ export const anthropic = {
         return fromWireResponse(data);
     },
 };
+async function loadModels(signal, onStatus) {
+    const entries = await modelCatalog(MODELS, headers(requireKey()), signal, onStatus);
+    return {
+        ids: entries.map((entry) => entry.id),
+        contexts: new Map(entries.map((entry) => [
+            entry.id,
+            contextWindow(entry.metadata["max_input_tokens"]),
+        ])),
+    };
+}
+function contextWindow(value) {
+    return validTokenCount(value) ? Object.freeze({ tokens: value }) : undefined;
+}
+function validTokenCount(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) &&
+        value >= 4_096 && value <= 10_000_000;
+}
 // Read at the moment it is used, never captured at import: a key typed into
 // the running window has to count, and so does one exported after startup.
 function apiKey() {

package/dist/providers/catalog.js

@@ -13,6 +13,9 @@ export const MAX_MODEL_CATALOG_ENTRIES = 1_000;
 export const MAX_MODEL_CATALOG_ITEMS = 4_000;
 export const MAX_MODEL_ID_CHARS = 256;
 export async function listModels(url, headers, signal, onStatus) {
+    return (await modelCatalog(url, headers, signal, onStatus)).map((entry) => entry.id);
+}
+export async function modelCatalog(url, headers, signal, onStatus) {
     const body = await getJson(url, headers, signal, onStatus);
     const data = body.data;
     if (!Array.isArray(data))
@@ -22,16 +25,20 @@ export async function listModels(url, headers, signal, onStatus) {
     const inspected = Math.min(data.length, MAX_MODEL_CATALOG_ITEMS);
     for (let index = 0; index < inspected && models.length < MAX_MODEL_CATALOG_ENTRIES; index++) {
         const entry = data[index];
-        const id = typeof entry === "object" && entry !== null
-            ? entry.id
-            : undefined;
+        const metadata = record(entry) ? entry : undefined;
+        if (metadata === undefined)
+            continue;
+        const id = metadata["id"];
         if (typeof id !== "string" ||
             id === "" ||
             id.length > MAX_MODEL_ID_CHARS ||
             unique.has(id))
             continue;
         unique.add(id);
-        models.push(id);
+        models.push({ id, metadata });
     }
     return models;
 }
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/providers/ollama.js

@@ -6,7 +6,7 @@
 // pulled or the subscription grants — so the model has to be named with
 // --model.
 import { requireSupportedEffort } from "../effort.js";
-import { postSse } from "./http.js";
+import { getJson, postJson, postSse } from "./http.js";
 import { listModels } from "./catalog.js";
 import { keyFor } from "../credentials.js";
 import { assembleOllama } from "./ollama-stream.js";
@@ -16,6 +16,8 @@ const KEY = "OLLAMA_API_KEY";
 // Ollama also accepts `none`; Jecode's product-wide reasoning floor is `low`.
 const OLLAMA_EFFORTS = ["low", "medium", "high"];
 let configuredHost;
+const CONTEXT_CACHE_MS = 30_000;
+const contextByEndpoint = new Map();
 /** Set the endpoint selected for this process. Undefined restores key-aware inference. */
 export function configureOllama(host) {
     configuredHost = host === undefined ? undefined : parseOllamaEndpoint(host).baseUrl;
@@ -51,6 +53,21 @@ export const ollama = {
     async efforts() {
         return OLLAMA_EFFORTS;
     },
+    async contextWindow(model, signal, onStatus) {
+        const at = endpoint();
+        const cacheKey = `${at.baseUrl}\u0000${model}`;
+        const cached = contextByEndpoint.get(cacheKey);
+        if (cached !== undefined && cached.expiresAt > Date.now())
+            return cached.value;
+        const observed = await nativeContextWindow(at, model, signal, onStatus);
+        if (observed?.runtime === true) {
+            contextByEndpoint.set(cacheKey, {
+                value: observed.value,
+                expiresAt: Date.now() + CONTEXT_CACHE_MS,
+            });
+        }
+        return observed?.value;
+    },
     location: () => {
         try {
             return endpoint().loopback ? "local" : "cloud";
@@ -79,6 +96,63 @@ export const ollama = {
         return fromWireReply(reply);
     },
 };
+async function nativeContextWindow(at, model, signal, onStatus) {
+    try {
+        const running = await getJson(`${at.baseUrl}/api/ps`, headers(at), signal, onStatus);
+        const allocated = runningContext(running, model);
+        if (allocated !== undefined)
+            return { value: usableContext(allocated), runtime: true };
+    }
+    catch (error) {
+        throwIfAborted(signal, error);
+    }
+    try {
+        const details = await postJson(`${at.baseUrl}/api/show`, headers(at), { model }, signal, onStatus);
+        const capacity = modelCapacity(details);
+        return capacity === undefined
+            ? undefined
+            : { value: usableContext(capacity), runtime: false };
+    }
+    catch (error) {
+        throwIfAborted(signal, error);
+        return undefined;
+    }
+}
+function runningContext(value, model) {
+    if (!record(value) || !Array.isArray(value["models"]))
+        return undefined;
+    for (const entry of value["models"]) {
+        if (!record(entry))
+            continue;
+        if (entry["name"] !== model && entry["model"] !== model)
+            continue;
+        if (validTokenCount(entry["context_length"]))
+            return entry["context_length"];
+    }
+    return undefined;
+}
+function modelCapacity(value) {
+    if (!record(value) || !record(value["model_info"]))
+        return undefined;
+    const capacities = Object.entries(value["model_info"])
+        .filter(([name, count]) => name.endsWith(".context_length") && validTokenCount(count))
+        .map(([, count]) => count);
+    return capacities.length === 0 ? undefined : Math.max(...capacities);
+}
+function validTokenCount(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) &&
+        value >= 4_096 && value <= 10_000_000;
+}
+function usableContext(tokens) {
+    return Object.freeze({ tokens: Math.floor(tokens * 95 / 100) });
+}
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function throwIfAborted(signal, error) {
+    if (signal?.aborted === true)
+        throw error;
+}
 function endpoint() {
     return ollamaConnection();
 }

package/dist/providers/openai-codex.js

@@ -19,6 +19,7 @@ const MAX_MODELS = 1_000;
 const MAX_MODEL_CHARS = 256;
 const XHIGH_EFFORTS = ["low", "medium", "high", "xhigh"];
 let effortByModel = new Map();
+let contextByModel = new Map();
 export const openaiCodex = {
     id: ID,
     defaultModel: "",
@@ -29,7 +30,7 @@ export const openaiCodex = {
     location: () => "cloud",
     async models(signal, onStatus) {
         const catalog = await loadCatalog(signal, onStatus);
-        effortByModel = catalog.efforts;
+        rememberCatalog(catalog);
         return catalog.ids;
     },
     async efforts(model, signal, onStatus) {
@@ -37,9 +38,19 @@ export const openaiCodex = {
         if (cached !== undefined)
             return cached;
         const catalog = await loadCatalog(signal, onStatus);
-        effortByModel = catalog.efforts;
+        rememberCatalog(catalog);
         return effortByModel.get(model) ?? fallbackEfforts(model);
     },
+    async contextWindow(model, signal, onStatus) {
+        if (contextByModel.has(model))
+            return contextByModel.get(model);
+        const catalog = await loadCatalog(signal, onStatus);
+        rememberCatalog(catalog);
+        const context = contextByModel.get(model);
+        if (!contextByModel.has(model))
+            contextByModel.set(model, undefined);
+        return context;
+    },
     async send(req) {
         const efforts = effortByModel.get(req.model) ?? fallbackEfforts(req.model);
         const effort = requireSupportedEffort(req.model, req.effort, efforts);
@@ -75,6 +86,10 @@ async function loadCatalog(signal, onStatus) {
         return modelCatalog(body);
     }, signal, onStatus);
 }
+function rememberCatalog(catalog) {
+    effortByModel = catalog.efforts;
+    contextByModel = catalog.contexts;
+}
 async function withAuthorization(operation, signal, onStatus) {
     let authorization = await openAIAuthorization(undefined, signal, onStatus);
     try {
@@ -120,6 +135,7 @@ function modelCatalog(value) {
                 id,
                 priority: typeof entry["priority"] === "number" ? entry["priority"] : 0,
                 efforts: reasoningLevels(entry, id),
+                context: modelContextWindow(entry),
             }];
     })
         .sort((left, right) => left.priority - right.priority)
@@ -127,8 +143,36 @@ function modelCatalog(value) {
     return {
         ids: models.map((entry) => entry.id),
         efforts: new Map(models.map((entry) => [entry.id, entry.efforts])),
+        contexts: new Map(models.map((entry) => [entry.id, entry.context])),
     };
 }
+function modelContextWindow(entry) {
+    const resolved = tokenCount(entry["context_window"]) ?? tokenCount(entry["max_context_window"]);
+    if (resolved === undefined)
+        return undefined;
+    const percent = percentage(entry["effective_context_window_percent"]) ?? 95;
+    const tokens = Math.floor(resolved * percent / 100);
+    if (!validTokenCount(tokens))
+        return undefined;
+    const automatic = Math.floor(resolved * 9 / 10);
+    const advertised = tokenCount(entry["auto_compact_token_limit"]);
+    return Object.freeze({
+        tokens,
+        compactAtTokens: Math.min(advertised ?? automatic, automatic, tokens),
+    });
+}
+function tokenCount(value) {
+    return validTokenCount(value) ? value : undefined;
+}
+function validTokenCount(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) &&
+        value >= 4_096 && value <= 10_000_000;
+}
+function percentage(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 && value <= 100
+        ? value
+        : undefined;
+}
 function reasoningLevels(entry, model) {
     const source = entry["supported_reasoning_levels"];
     if (!Array.isArray(source))

package/dist/providers/openai.js

@@ -37,6 +37,20 @@ export function openAIEfforts(model) {
         return STANDARD_EFFORTS;
     return STANDARD_EFFORTS;
 }
+/** Conservative capacities for the reasoning families accepted by this transport. */
+export function openAIContextWindow(model) {
+    if (/^gpt-5\.6(?:[.-]|$)/.test(model))
+        return usableContext(1_050_000);
+    if (/^gpt-5(?:[.-]|$)/.test(model))
+        return usableContext(400_000);
+    if (/^(?:o(?:1|3|4)|codex-mini)(?:[.-]|$)/.test(model)) {
+        return usableContext(200_000);
+    }
+    return undefined;
+}
+function usableContext(tokens) {
+    return Object.freeze({ tokens: Math.floor(tokens * 95 / 100) });
+}
 export const openai = {
     id: "openai",
     defaultModel: "gpt-5",
@@ -55,6 +69,9 @@ export const openai = {
     async efforts(model) {
         return openAIEfforts(model);
     },
+    async contextWindow(model) {
+        return openAIContextWindow(model);
+    },
     location: () => "cloud",
     async send(req) {
         const key = requireKey();

package/dist/sessions/codec.js

@@ -1,7 +1,8 @@
 // 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.
-export const SESSION_SCHEMA = 1;
+import { CONTEXT_LIMITS } from "../context/projection.js";
+export const SESSION_SCHEMA = 2;
 export const SESSION_FILE_LIMITS = Object.freeze({
     text: 1_048_576,
     jsonDepth: 24,
@@ -16,14 +17,14 @@ export function decodeMeta(value) {
     if (!record(value) || !keys(value, "createdAt,id,version,workspaceDigest,workspaceRoot")) {
         throw invalid();
     }
-    if (value["version"] !== SESSION_SCHEMA ||
+    if (!schema(value["version"]) ||
         !identifier(value["id"]) ||
         !bounded(value["workspaceRoot"], 32_768) ||
         !digest(value["workspaceDigest"]) ||
         !timestamp(value["createdAt"]))
         throw invalid();
     return Object.freeze({
-        version: 1,
+        version: value["version"],
         id: value["id"],
         workspaceRoot: value["workspaceRoot"],
         workspaceDigest: value["workspaceDigest"],
@@ -37,7 +38,7 @@ export function decodeHead(value) {
     if (!record(value) || !keys(value, "nodeId,parentId,revision,sequence,updatedAt,version")) {
         throw invalid();
     }
-    if (value["version"] !== SESSION_SCHEMA ||
+    if (!schema(value["version"]) ||
         !integer(value["sequence"], 0) ||
         !integer(value["nodeId"], 1) ||
         !integer(value["parentId"], 0) || value["parentId"] >= value["nodeId"] ||
@@ -45,7 +46,7 @@ export function decodeHead(value) {
         !timestamp(value["updatedAt"]))
         throw invalid();
     return Object.freeze({
-        version: 1,
+        version: value["version"],
         sequence: value["sequence"],
         nodeId: value["nodeId"],
         parentId: value["parentId"],
@@ -67,17 +68,22 @@ export function encodeNode(node, sequence, updatedAt) {
             identity: node.identity,
             messages: node.messages.map(messageRecord),
             blocks: node.blocks.flatMap(blockRecord),
+            context: node.context ?? null,
         },
     });
 }
 export function decodeNode(value) {
     if (!record(value) || !keys(value, "node,sequence,updatedAt,version"))
         throw invalid();
-    if (value["version"] !== SESSION_SCHEMA || !integer(value["sequence"], 1) ||
+    const version = value["version"];
+    if (!schema(version) || !integer(value["sequence"], 1) ||
         !timestamp(value["updatedAt"]))
         throw invalid();
     const raw = value["node"];
-    if (!record(raw) || !keys(raw, "blocks,createdAt,id,identity,messages,parentId,revision,settlement")) {
+    const nodeKeys = version === 1
+        ? "blocks,createdAt,id,identity,messages,parentId,revision,settlement"
+        : "blocks,context,createdAt,id,identity,messages,parentId,revision,settlement";
+    if (!record(raw) || !keys(raw, nodeKeys)) {
         throw invalid();
     }
     const identity = raw["identity"];
@@ -94,6 +100,9 @@ export function decodeNode(value) {
         !Array.isArray(messages) || messages.length > SESSION_FILE_LIMITS.blocks ||
         !Array.isArray(blocks) || blocks.length > SESSION_FILE_LIMITS.blocks)
         throw invalid();
+    const context = version === 1
+        ? undefined
+        : contextFromRecord(raw["context"], raw["id"], messages.length);
     const node = Object.freeze({
         id: raw["id"],
         parentId: raw["parentId"],
@@ -107,9 +116,29 @@ export function decodeNode(value) {
         }),
         messages: Object.freeze(messages.map(messageFromRecord)),
         blocks: Object.freeze(blocks.map(blockFromRecord)),
+        ...(context === undefined ? {} : { context: Object.freeze(context) }),
     });
     return Object.freeze({ sequence: value["sequence"], updatedAt: value["updatedAt"], node });
 }
+function contextFromRecord(value, ownerId, ownerMessages) {
+    if (value === null)
+        return undefined;
+    if (!record(value) || !keys(value, "createdAt,messageCount,summary,throughNodeId")) {
+        throw invalid();
+    }
+    if (!integer(value["throughNodeId"], 1) || value["throughNodeId"] > ownerId ||
+        !integer(value["messageCount"], 0) ||
+        (value["throughNodeId"] === ownerId && value["messageCount"] > ownerMessages) ||
+        !timestamp(value["createdAt"]) ||
+        !bounded(value["summary"], CONTEXT_LIMITS.summaryCodeUnits))
+        throw invalid();
+    return {
+        throughNodeId: value["throughNodeId"],
+        messageCount: value["messageCount"],
+        createdAt: value["createdAt"],
+        summary: value["summary"],
+    };
+}
 function messageRecord(message) {
     return {
         role: message.role,
@@ -326,6 +355,9 @@ function boundedText(value, limit = SESSION_FILE_LIMITS.text) {
 function integer(value, minimum) {
     return typeof value === "number" && Number.isSafeInteger(value) && value >= minimum;
 }
+function schema(value) {
+    return value === 1 || value === SESSION_SCHEMA;
+}
 function nullableInteger(value, minimum) {
     return value === null || integer(value, minimum);
 }