@giovannijecha/jecode 0.5.0 → 0.6.0

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);
 }

package/dist/sessions/store.js

@@ -9,7 +9,7 @@ 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, } from "./codec.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;
@@ -104,7 +104,7 @@ export class DurableSessionStore {
                 throw new Error("session checkpoint cannot be recovered safely");
             }
             head = {
-                version: 1,
+                version: SESSION_SCHEMA,
                 sequence: candidate.sequence,
                 nodeId: candidate.node.id,
                 parentId: candidate.node.parentId,
@@ -128,14 +128,14 @@ export class DurableSessionStore {
         const temporary = path.join(this.#bucket, `.${id}.${randomUUID()}.tmp`);
         const target = this.#sessionDirectory(id);
         const meta = {
-            version: 1,
+            version: SESSION_SCHEMA,
             id,
             workspaceRoot: this.workspaceRoot,
             workspaceDigest: this.workspaceDigest,
             createdAt: now,
         };
         const head = {
-            version: 1,
+            version: SESSION_SCHEMA,
             sequence: conversation.nodes.length,
             nodeId: active.id,
             parentId: active.parentId,
@@ -187,7 +187,7 @@ export class DurableSessionStore {
         assertSharedNodes(previous.conversation, conversation, replacesHead ? active.id : undefined);
         const now = new Date().toISOString();
         const head = {
-            version: 1,
+            version: SESSION_SCHEMA,
             sequence: previous.head.sequence + 1,
             nodeId: active.id,
             parentId: active.parentId,

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" });