@giovannijecha/jecode 0.6.0 → 0.7.0

package/README.md

@@ -25,7 +25,7 @@
   <a href="https://github.com/giovannijecha/jecode/releases">Releases</a>
 </p>
 
-> Jecode is an early 0.6.x release. The core loop is usable today; commands and
+> Jecode is an early 0.7.x release. The core loop is usable today; commands and
 > terminal interactions may still evolve before 1.0.
 
 ## Why Jecode
@@ -201,6 +201,8 @@ Type **/** to open searchable command completion inside the composer.
 | /models | Search models across every available provider and select one |
 | /permissions | Change session tool access inline and review remembered approvals |
 | /new | Close the current conversation, start clean, and reset tool permissions |
+| /timeline | Navigate completed turns and select where the next branch starts |
+| /compact | Compact the active model context immediately |
 | /export | Save a timestamped Markdown transcript in the launch directory |
 | /help | Open a temporary keyboard reference in the composer dock |
 | /exit | Restore the terminal and exit |
@@ -264,10 +266,15 @@ files use owner-only modes on POSIX; Windows relies on the user-profile ACL.
 `jecode resume` keeps the same durable session identity and advances that
 session's conversation tree, so reopening and continuing a conversation does
 not create duplicate picker entries. `/new` or a fresh launch starts another
-logical session. Resume never executes an old tool call. If a crash left the
-newest turn inside a tool loop, the same session resumes from its latest
-completed ancestor and the next turn becomes a branch inside its tree because
-provider-only continuation data is intentionally not stored.
+logical session. **/timeline** shows the completed turns in that tree. Selecting
+an earlier turn changes only the visible path; it creates and persists a branch
+only when the next real message is sent. Cancelling the picker or exiting first
+leaves the durable head untouched, and resume returns to the last branch with a
+persisted turn. Historical tools are displayed but never executed. If a crash
+left the newest turn inside a tool loop, the same session resumes from its
+latest completed ancestor and the next turn becomes a branch because
+provider-only continuation data is intentionally not stored. **/export** writes
+only the currently selected path.
 
 When the model-facing context approaches the selected model's usable capacity,
 Jecode asks the provider for one bounded summary of its older prefix and keeps
@@ -281,7 +288,11 @@ session, so resume reuses it instead of summarizing the same prefix again. A
 failed or cancelled optional summary leaves the original context intact; a
 definite provider context-limit rejection may trigger one compacted retry.
 Internal summary requests count toward provider usage but never appear in the
-transcript or Markdown export.
+transcript or Markdown export. **/compact** requests the same model-aware,
+branch-local compaction immediately, even below the automatic trigger. Very
+small contexts are left unchanged. After selecting a historical branch point,
+send its first new message before compacting so shared history is never
+rewritten.
 
 Jecode has one interface theme: dark Steel. **NO_COLOR** is supported for
 terminals and pipelines that disable colour.

package/dist/batch.js

@@ -7,6 +7,7 @@ import { stdin, stdout } from "node:process";
 import { runTurn } from "./controller.js";
 import { resolveContextPolicy } from "./context/capacity.js";
 import { compactContext } from "./context/compactor.js";
+import { compactSession } from "./context/manual.js";
 import { isContextOverflow, shouldResolveContextPolicy } from "./context/policy.js";
 import { handleCommand } from "./commands.js";
 import { renderBatch } from "./batch-view.js";
@@ -28,7 +29,10 @@ export async function runBatch(session, environment = {}) {
             if (line === "")
                 continue;
             if (line.startsWith("/")) {
-                if ((await handleCommand(line, session, { emit })) === "exit")
+                if ((await handleCommand(line, session, {
+                    emit,
+                    compact: () => compactSession(session),
+                })) === "exit")
                     break;
                 continue;
             }

package/dist/commands.js

@@ -1,9 +1,8 @@
 // Slash-command registry and dispatcher.
 //
-// One of them does reach the network — a menu of models cannot be built
-// without asking the provider what it has — but none of them ever sends a
-// message. Provider access and model selection stay in their own commands;
-// this file keeps discovery, dispatch, and local session operations.
+// Model discovery and explicit context compaction can reach a provider, but
+// slash commands never become user messages. This file keeps discovery,
+// dispatch, and session operations outside the canonical transcript.
 import { ConversationTree } from "./conversation.js";
 import { modelsCommand } from "./model-command.js";
 import { providersCommand } from "./provider-commands.js";
@@ -22,6 +21,8 @@ export const COMMANDS = [
     { name: "exit", blurb: "exit and restore the terminal" },
     { name: "new", blurb: "start clean and reset tool permissions" },
     { name: "export", blurb: "save this transcript as Markdown" },
+    { name: "timeline", blurb: "navigate this conversation tree" },
+    { name: "compact", blurb: "compact the active context now" },
     { name: "permissions", blurb: "manage session tool access" },
     { name: "settings", blurb: "change and save jecode defaults" },
     { name: "effort", blurb: "set the reasoning effort" },
@@ -51,6 +52,39 @@ export async function handleCommand(line, session, host) {
             session.usage = emptyUsage();
             host.emit({ kind: "notice", text: "new session", tone: "info" });
             return "handled";
+        case "timeline": {
+            if (host.timeline === undefined) {
+                host.emit({ kind: "notice", text: "timeline needs the interactive screen", tone: "warn" });
+                return "handled";
+            }
+            const result = await host.timeline();
+            if (result === "selected") {
+                host.emit({
+                    kind: "notice",
+                    text: "branch point selected · send a message to continue",
+                    tone: "info",
+                });
+            }
+            return "handled";
+        }
+        case "compact": {
+            if (host.compact === undefined) {
+                host.emit({ kind: "notice", text: "compact is unavailable here", tone: "warn" });
+                return "handled";
+            }
+            const result = await host.compact();
+            if (result === "compacted") {
+                host.emit({ kind: "notice", text: "context compacted", tone: "info" });
+            }
+            else if (result === "branch-pending") {
+                host.emit({
+                    kind: "notice",
+                    text: "send a message on this branch before compacting",
+                    tone: "warn",
+                });
+            }
+            return "handled";
+        }
         case "export":
             if (host.exportTranscript === undefined) {
                 host.emit({ kind: "notice", text: "export needs the interactive screen", tone: "warn" });
@@ -84,9 +118,3 @@ export async function handleCommand(line, session, host) {
             return "handled";
     }
 }
-function chooser(host) {
-    if (host.choose === undefined) {
-        host.emit({ kind: "notice", text: "that command needs the screen", tone: "warn" });
-    }
-    return host.choose;
-}

package/dist/context/compactor.js

@@ -45,7 +45,9 @@ export async function compactContext(options) {
             ...(response.usage === undefined ? {} : { usage: response.usage }),
         };
     }
-    catch {
+    catch (error) {
+        if (options.failLoudly === true)
+            throw error;
         return undefined;
     }
     finally {

package/dist/context/manual.js

@@ -0,0 +1,69 @@
+// Explicit compaction of the selected durable leaf.
+//
+// The canonical messages and transcript remain untouched. Only the active
+// leaf receives a new branch-local context anchor, using the same provider
+// policy and summarizer as automatic compaction.
+import { recordAuxiliaryUsage } from "../usage.js";
+import { resolveContextPolicy } from "./capacity.js";
+import { compactContext } from "./compactor.js";
+import { estimateTokens, planCompaction } from "./policy.js";
+const MIN_PREFIX_TOKENS = 512;
+export async function compactSession(session, options = {}) {
+    const active = session.conversation.activeNode;
+    if (active === undefined)
+        return "unchanged";
+    const context = session.conversation.contextHistory;
+    if (estimateTokens(context) < MIN_PREFIX_TOKENS)
+        return "unchanged";
+    if (session.conversation.nodes.some((node) => node.parentId === active.id)) {
+        throw new Error("continue this branch before compacting");
+    }
+    options.onStatus?.("Checking context");
+    const policy = await resolveContextPolicy({
+        provider: session.provider,
+        model: session.model,
+        compactionPercent: session.config.compactionPercent,
+        signal: options.signal,
+        onStatus: (status) => options.onStatus?.(status),
+    });
+    const coveredMessages = active.context?.throughNodeId === active.id
+        ? active.context.messageCount
+        : 0;
+    const plan = planCompaction(context, active.messages, coveredMessages, session.usage.lastInputTokens, true, policy);
+    if (plan === undefined || estimateTokens(plan.prefix) < MIN_PREFIX_TOKENS) {
+        options.onStatus?.();
+        return "unchanged";
+    }
+    const result = await compactContext({
+        provider: session.provider,
+        model: session.model,
+        effort: session.config.effort,
+        context,
+        turn: active.messages,
+        nodeId: active.id,
+        coveredMessages,
+        lastInputTokens: session.usage.lastInputTokens,
+        signal: options.signal,
+        force: true,
+        failLoudly: true,
+        policy,
+        onBegin: () => options.onStatus?.("Compacting"),
+        onEnd: () => options.onStatus?.(),
+    });
+    if (result === undefined)
+        throw new Error("context could not be compacted");
+    if (result.usage !== undefined)
+        recordAuxiliaryUsage(session.usage, result.usage);
+    const next = session.conversation.commit({
+        nodeId: active.id,
+        parentId: active.parentId,
+        createdAt: active.createdAt,
+        identity: active.identity,
+        messages: active.messages,
+        blocks: active.blocks,
+        context: result.anchor,
+    }, active.settlement);
+    await session.persistence?.checkpoint(next);
+    session.conversation = next;
+    return "compacted";
+}

package/dist/settings-command.js

@@ -202,7 +202,7 @@ async function compactionSetting(session, host) {
     const label = "context compaction";
     const field = {
         title: heading(label, `${MIN_COMPACTION_PERCENT}-${MAX_COMPACTION_PERCENT} percent`, session.palette),
-        right: "enter save · esc back",
+        right: "enter save · esc back",
         editor: of(String(session.config.compactionPercent)),
         secret: false,
         note: "Compacts when model context reaches this percentage.",

package/dist/timeline.js

@@ -0,0 +1,90 @@
+// A compact, read-only projection of the durable conversation tree.
+//
+// Selecting a node changes only the in-memory path. The next real user turn
+// is what persists a branch, so opening or cancelling this control plane can
+// never create empty history.
+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 index = Math.max(0, entries.findIndex((entry) => entry.node.id === selectedId));
+    return Object.freeze({
+        picker: {
+            title: heading("timeline", "conversation tree", palette),
+            searchable: true,
+            query: "",
+            visible: 8,
+            options: entries.map((entry) => ({
+                label: `${entry.prefix}${preview(entry.node)}`,
+                hint: stamp(entry.node.createdAt),
+                ...(entry.node.id === selectedId ? { value: "active" } : {}),
+            })),
+            index,
+        },
+        nodeIds: Object.freeze(entries.map((entry) => entry.node.id)),
+    });
+}
+export async function selectTimeline(session, choose) {
+    const timeline = timelinePicker(session.conversation, session.palette);
+    if (timeline.nodeIds.length === 0)
+        return false;
+    const index = await choose(timeline.picker);
+    const nodeId = index === undefined ? undefined : timeline.nodeIds[index];
+    if (nodeId === undefined || nodeId === session.conversation.activeNodeId)
+        return false;
+    session.conversation = session.conversation.select(nodeId);
+    session.usage = usageFromHistory(session.conversation.history);
+    return true;
+}
+function timelineEntries(conversation) {
+    const completed = conversation.nodes.filter((node) => node.settlement === "completed");
+    const completedIds = new Set(completed.map((node) => node.id));
+    const children = new Map();
+    for (const node of completed) {
+        let parentId = node.parentId;
+        while (parentId !== 0 && !completedIds.has(parentId)) {
+            parentId = conversation.node(parentId)?.parentId ?? 0;
+        }
+        const siblings = children.get(parentId) ?? [];
+        siblings.push(node);
+        children.set(parentId, siblings);
+    }
+    const entries = [];
+    const visit = (parentId, lanes) => {
+        const siblings = children.get(parentId) ?? [];
+        for (let index = 0; index < siblings.length; index++) {
+            const node = siblings[index];
+            const forks = siblings.length > 1;
+            const last = index === siblings.length - 1;
+            const hidden = Math.max(0, lanes.length - 4);
+            const lanePrefix = `${hidden === 0 ? "" : "…  "}${lanes.slice(hidden)
+                .map((closed) => closed ? "   " : "│  ").join("")}`;
+            entries.push({
+                node,
+                prefix: `${lanePrefix}${forks ? (last ? "└─ " : "├─ ") : "• "}`,
+            });
+            visit(node.id, forks ? [...lanes, last] : lanes);
+        }
+    };
+    visit(0, []);
+    return entries;
+}
+function preview(node) {
+    for (const message of node.messages) {
+        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 turn";
+}
+function stamp(value) {
+    const date = new Date(value);
+    if (!Number.isFinite(date.getTime()))
+        return value.replace("T", " ").slice(0, 16);
+    const two = (part) => String(part).padStart(2, "0");
+    return `${two(date.getHours())}:${two(date.getMinutes())}`;
+}

package/dist/tui/app-state.js

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

package/dist/tui/app-workflows.js

@@ -3,10 +3,12 @@ import { handleCommand } from "../commands.js";
 import { runTurn } from "../controller.js";
 import { resolveContextPolicy } from "../context/capacity.js";
 import { compactContext } from "../context/compactor.js";
+import { compactSession } from "../context/manual.js";
 import { isContextOverflow, shouldResolveContextPolicy } from "../context/policy.js";
 import { updateSettings } from "../settings.js";
 import { saveTranscript } from "../transcript-export.js";
 import { recordAuxiliaryUsage, recordUsage } from "../usage.js";
+import { selectTimeline } from "../timeline.js";
 import { answerAt } from "./approve.js";
 import { cancel as cancelOpen } from "./overlay.js";
 import { controllerOptions, turnFailure } from "./session-view.js";
@@ -14,6 +16,10 @@ import { transcribe } from "./turn.js";
 const WAITING = "Waiting";
 export function appWorkflows(options) {
     const { session, state, permissions, feedback } = options;
+    const choose = (picker) => new Promise((resolve) => {
+        state.open = { picker, settle: resolve };
+        options.render();
+    });
     async function command(text) {
         const activity = options.startActivity("command", `Running ${text.split(/\s+/)[0]}`);
         if (activity === undefined)
@@ -26,10 +32,7 @@ export function appWorkflows(options) {
                     state.open = { help: true, settle: resolve };
                     options.render();
                 }),
-                choose: (picker) => new Promise((resolve) => {
-                    state.open = { picker, settle: resolve };
-                    options.render();
-                }),
+                choose,
                 dismiss: () => {
                     state.open = state.open === undefined ? undefined : cancelOpen(state.open);
                     options.render();
@@ -51,6 +54,7 @@ export function appWorkflows(options) {
                     state.follow = true;
                     state.unseen = 0;
                     state.lastMaxScroll = 0;
+                    state.committedNodeId = 0;
                 },
                 permissions,
                 exportTranscript: () => saveTranscript(options.transcriptRoot, state.blocks),
@@ -58,6 +62,27 @@ export function appWorkflows(options) {
                     await updateSettings(patch);
                 },
                 refreshSettings: options.refreshSettings,
+                timeline: async () => {
+                    const selected = await selectTimeline(session, choose);
+                    if (!selected)
+                        return "unchanged";
+                    options.replaceTranscript();
+                    return session.conversation.activeNodeId === state.committedNodeId
+                        ? "unchanged"
+                        : "selected";
+                },
+                compact: async () => {
+                    if (session.conversation.activeNodeId !== state.committedNodeId) {
+                        return "branch-pending";
+                    }
+                    return compactSession(session, {
+                        signal: activity.control.signal,
+                        onStatus: (status) => {
+                            state.status = status ?? activity.label;
+                            options.render();
+                        },
+                    });
+                },
             });
             if (outcome === "exit")
                 state.closeWhenIdle = true;
@@ -128,6 +153,7 @@ export function appWorkflows(options) {
             await session.persistence?.checkpoint(next);
             session.conversation = next;
             nodeId = next.activeNodeId;
+            state.committedNodeId = next.activeNodeId;
         };
         const compact = async (checkpoint, projected, reason, error) => {
             if (reason === "overflow" && (error === undefined || !isContextOverflow(error))) {

package/dist/tui/app.js

@@ -32,6 +32,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     const workspace = await workspaceLabel(session.config.root);
     const state = appState();
     state.blocks.push(...session.conversation.transcript);
+    state.committedNodeId = session.conversation.activeNodeId;
     const permissions = sessionPermissions(session.tools, session.config.autoApprove);
     let closed;
     let frameTimer;
@@ -116,6 +117,16 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         if (state.follow)
             state.unseen = 0;
     };
+    const replaceTranscript = () => {
+        state.blocks.splice(0, state.blocks.length, ...session.conversation.transcript);
+        state.scroll = 0;
+        state.follow = true;
+        state.unseen = 0;
+        state.lastMaxScroll = 0;
+        transcript.invalidate();
+        paint.invalidate();
+        render();
+    };
     function quit() {
         if (!live)
             return;
@@ -187,6 +198,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         emit,
         commandNotice,
         render,
+        replaceTranscript,
         refreshSettings: () => {
             terminal.setReducedMotion(session.config.reducedMotion);
             paint.invalidate();
@@ -229,14 +241,9 @@ export async function runApp(session, transcriptRoot, environment = {}) {
                 return;
             try {
                 await launch.open(candidate.id);
-                state.blocks.splice(0, state.blocks.length, ...session.conversation.transcript);
+                replaceTranscript();
+                state.committedNodeId = session.conversation.activeNodeId;
                 state.past.length = 0;
-                state.scroll = 0;
-                state.follow = true;
-                state.unseen = 0;
-                state.lastMaxScroll = 0;
-                transcript.invalidate();
-                paint.invalidate();
                 finishActivity(activity);
                 return;
             }

package/dist/tui/components/misc.js

@@ -5,11 +5,13 @@ export function renderNotice(block, width, pal) {
         warn: pal.ink.attention,
         error: pal.ink.removed,
     };
-    const mark = block.tone === "error" ? "× " : block.tone === "warn" ? "! " : "· ";
+    const mark = block.tone === "error" ? "× " : block.tone === "warn" ? "! " : undefined;
     return [
         "",
         ...wrap(block.text, Math.max(1, width - 3)).map((line, index) => row(width, [
-            { text: index === 0 ? mark : "  ", fg: fg[block.tone], bold: index === 0 },
+            ...(mark === undefined
+                ? []
+                : [{ text: index === 0 ? mark : "  ", fg: fg[block.tone], bold: index === 0 }]),
             { text: line, fg: fg[block.tone] },
         ], [], undefined, 1)),
     ];

package/package.json

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