@giovannijecha/jecode 0.8.0 → 0.8.2

package/dist/context/budget.js

@@ -18,10 +18,17 @@ export function estimateRequestInputTokens(envelope) {
 }
 /** Clamp the configured output ceiling so the complete request remains usable. */
 export function budgetRequest(envelope, configuredMaxOutputTokens, policy) {
-    if (!Number.isSafeInteger(configuredMaxOutputTokens) || configuredMaxOutputTokens <= 0) {
-        throw new Error("max output tokens must be a positive safe integer");
-    }
+    requirePositiveInteger(configuredMaxOutputTokens, "max output tokens");
     const inputTokens = estimateRequestInputTokens(envelope);
+    return finishBudget(inputTokens, configuredMaxOutputTokens, policy);
+}
+/** Reuse an exact estimate already computed for the same request envelope. */
+export function budgetRequestFromInputTokens(inputTokens, configuredMaxOutputTokens, policy) {
+    requirePositiveInteger(inputTokens, "request input tokens");
+    requirePositiveInteger(configuredMaxOutputTokens, "max output tokens");
+    return finishBudget(inputTokens, configuredMaxOutputTokens, policy);
+}
+function finishBudget(inputTokens, configuredMaxOutputTokens, policy) {
     const available = policy.requestLimitTokens - inputTokens;
     const minimum = Math.min(configuredMaxOutputTokens, MIN_REQUEST_OUTPUT_TOKENS);
     if (available < minimum) {
@@ -35,3 +42,8 @@ export function budgetRequest(envelope, configuredMaxOutputTokens, policy) {
         limitTokens: policy.requestLimitTokens,
     });
 }
+function requirePositiveInteger(value, label) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new Error(`${label} must be a positive safe integer`);
+    }
+}

package/dist/controller-request.js

@@ -1,17 +1,14 @@
 // One streamed provider request with a single safe context-overflow recovery.
-import { budgetRequest, estimateRequestInputTokens } from "./context/budget.js";
+import { budgetRequestFromInputTokens, estimateRequestInputTokens, } from "./context/budget.js";
 import { isContextOverflow } from "./context/policy.js";
 export async function requestAssistant(history, current, specs, options, events, signal) {
     let policy = await options.contextPolicy();
     const prepared = await prepareContext(history, current, specs, options, events, policy, "budget");
-    let context = prepared === undefined ? [...current] : clone(prepared);
+    let context = prepared.projected === undefined ? [...current] : clone(prepared.projected);
+    let inputTokens = prepared.inputTokens;
     let recovered = false;
     for (;;) {
-        const budget = budgetRequest({
-            system: options.system,
-            messages: context,
-            tools: specs,
-        }, options.maxTokens, policy);
+        const budget = budgetRequestFromInputTokens(inputTokens, options.maxTokens, policy);
         try {
             const message = await options.provider.send({
                 model: options.model,
@@ -31,10 +28,11 @@ export async function requestAssistant(history, current, specs, options, events,
                 throw error;
             if (isContextOverflow(error))
                 policy = await options.contextPolicy();
-            const projected = await prepareContext(history, context, specs, options, events, policy, "overflow", error);
-            if (projected === undefined)
+            const next = await prepareContext(history, context, specs, options, events, policy, "overflow", error);
+            if (next.projected === undefined)
                 throw error;
-            context = clone(projected);
+            context = clone(next.projected);
+            inputTokens = next.inputTokens;
             recovered = true;
         }
     }
@@ -45,12 +43,22 @@ async function prepareContext(history, context, specs, options, events, policy,
         messages: context,
         tools: specs,
     });
-    return events.onContext?.(history, context, {
+    const projected = await events.onContext?.(history, context, {
         reason,
         policy,
         inputTokens,
         ...(error === undefined ? {} : { error }),
     });
+    return {
+        projected,
+        inputTokens: projected === undefined
+            ? inputTokens
+            : estimateRequestInputTokens({
+                system: options.system,
+                messages: projected,
+                tools: specs,
+            }),
+    };
 }
 function clone(messages) {
     return structuredClone([...messages]);

package/dist/controller.js

@@ -97,13 +97,29 @@ export async function runTurn(history, options, events, signal, modelHistory = h
                     events.onToolCall(call, preview);
                     prepared.push({ call, current, preview });
                 }
-                const runs = await Promise.all(prepared.map(({ call, current, preview }) => settle(call, current, calls.length, options, events, signal, preview)));
-                for (let offset = 0; offset < runs.length; offset++) {
+                const settlements = await Promise.allSettled(prepared.map(({ call, current, preview }) => settle(call, current, calls.length, options, events, signal, preview)));
+                let batchFailure;
+                for (let offset = 0; offset < settlements.length; offset++) {
                     const call = prepared[offset]?.call;
-                    const run = runs[offset];
+                    const settlement = settlements[offset];
+                    const run = settlement.status === "fulfilled"
+                        ? settlement.value
+                        : refuse(call, signal?.aborted === true
+                            ? "interrupted before completion"
+                            : "tool processing stopped before completion", signal?.aborted === true ? "interrupted" : "failed");
+                    if (settlement.status === "rejected" && batchFailure === undefined) {
+                        batchFailure = { error: settlement.reason };
+                    }
                     results.push(run.result);
-                    events.onToolResult(call, run.result, run.summary);
+                    try {
+                        events.onToolResult(call, run.result, run.summary);
+                    }
+                    catch (error) {
+                        batchFailure ??= { error };
+                    }
                 }
+                if (batchFailure !== undefined)
+                    throw batchFailure.error;
             }
         }
         catch (error) {

package/dist/openai-oauth.js

@@ -17,6 +17,8 @@ const DEVICE_POLL = `${AUTHORITY}/api/accounts/deviceauth/token`;
 const DEVICE_VERIFY = `${AUTHORITY}/codex/device`;
 const DEVICE_REDIRECT = `${AUTHORITY}/deviceauth/callback`;
 const LOGIN_LIMIT_MS = 15 * 60_000;
+/** RFC 8628 increases the polling interval by five seconds after `slow_down`. */
+const SLOW_DOWN_INCREMENT_MS = 5_000;
 export async function beginBrowserLogin() {
     const verifier = randomBytes(64).toString("base64url");
     const challenge = createHash("sha256").update(verifier).digest("base64url");
@@ -121,23 +123,65 @@ async function exchange(code, signal) {
     return openAITokenReply(response.value);
 }
 async function pollDevice(deviceAuthId, userCode, interval, signal) {
-    const started = Date.now();
-    while (Date.now() - started < LOGIN_LIMIT_MS) {
-        const response = await oauthRequest(DEVICE_POLL, {
-            contentType: "application/json",
-            value: { device_auth_id: deviceAuthId, user_code: userCode },
-        }, signal, [200, 403, 404]);
-        if (response.status === 200) {
-            const value = record(response.value) ? response.value : {};
-            return {
-                authorizationCode: required(value["authorization_code"], "authorization code"),
-                verifier: required(value["code_verifier"], "code verifier"),
-                redirectUri: DEVICE_REDIRECT,
-            };
+    const deadline = new AbortController();
+    const timer = setTimeout(() => {
+        deadline.abort(new Error("ChatGPT device sign-in timed out after 15 minutes"));
+    }, LOGIN_LIMIT_MS);
+    const combined = signal === undefined
+        ? deadline.signal
+        : AbortSignal.any([signal, deadline.signal]);
+    let intervalMs = interval * 1_000;
+    try {
+        while (true) {
+            const response = await oauthRequest(DEVICE_POLL, {
+                contentType: "application/json",
+                value: { device_auth_id: deviceAuthId, user_code: userCode },
+            }, combined, [200, 400, 403, 404, 429]);
+            if (combined.aborted)
+                throw abortReason(combined);
+            if (response.status === 200) {
+                const value = record(response.value) ? response.value : {};
+                return {
+                    authorizationCode: required(value["authorization_code"], "authorization code"),
+                    verifier: required(value["code_verifier"], "code verifier"),
+                    redirectUri: DEVICE_REDIRECT,
+                };
+            }
+            const errorCode = deviceErrorCode(response.value);
+            if (errorCode === "access_denied") {
+                throw new Error("ChatGPT device sign-in was denied");
+            }
+            if (errorCode === "expired_token") {
+                throw new Error("ChatGPT device sign-in code expired");
+            }
+            const pending = errorCode === "authorization_pending" ||
+                errorCode === "deviceauth_authorization_pending" ||
+                ((response.status === 403 || response.status === 404) && errorCode === undefined);
+            const slowDown = errorCode === "slow_down" ||
+                (response.status === 429 && errorCode === undefined);
+            if (!pending && !slowDown) {
+                throw new Error(`ChatGPT device sign-in failed (${response.status})`);
+            }
+            if (slowDown)
+                intervalMs += SLOW_DOWN_INCREMENT_MS;
+            await sleep(intervalMs, combined);
         }
-        await sleep(interval * 1_000, signal);
     }
-    throw new Error("ChatGPT device sign-in timed out after 15 minutes");
+    finally {
+        clearTimeout(timer);
+    }
+}
+function deviceErrorCode(value) {
+    if (!record(value))
+        return undefined;
+    const error = value["error"];
+    const nested = typeof error === "string"
+        ? error
+        : record(error)
+            ? optional(error["code"])
+            : undefined;
+    const code = nested ?? optional(value["code"]);
+    return code?.trim().toLowerCase();
 }
 function intervalSeconds(value) {
     const parsed = typeof value === "string" ? Number(value.trim()) : value;

package/dist/providers/ollama.js

@@ -17,7 +17,8 @@ const KEY = "OLLAMA_API_KEY";
 const OLLAMA_EFFORTS = ["low", "medium", "high"];
 let configuredHost;
 const CONTEXT_CACHE_MS = 30_000;
-const contextByEndpoint = new Map();
+const runtimeContextByEndpoint = new Map();
+const modelContextByEndpoint = 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;
@@ -56,15 +57,16 @@ export const ollama = {
     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);
+        const runtime = cachedContext(runtimeContextByEndpoint, cacheKey);
+        if (runtime !== undefined)
+            return runtime;
+        const modelCapacity = cachedContext(modelContextByEndpoint, cacheKey);
+        const observed = await nativeContextWindow(at, model, modelCapacity, signal, onStatus);
         if (observed?.runtime === true) {
-            contextByEndpoint.set(cacheKey, {
-                value: observed.value,
-                expiresAt: Date.now() + CONTEXT_CACHE_MS,
-            });
+            rememberContext(runtimeContextByEndpoint, cacheKey, observed.value);
+        }
+        else if (observed !== undefined && modelCapacity === undefined) {
+            rememberContext(modelContextByEndpoint, cacheKey, observed.value);
         }
         return observed?.value;
     },
@@ -96,7 +98,7 @@ export const ollama = {
         return fromWireReply(reply);
     },
 };
-async function nativeContextWindow(at, model, signal, onStatus) {
+async function nativeContextWindow(at, model, fallback, signal, onStatus) {
     try {
         const running = await getJson(`${at.baseUrl}/api/ps`, headers(at), signal, onStatus);
         const allocated = runningContext(running, model);
@@ -106,6 +108,8 @@ async function nativeContextWindow(at, model, signal, onStatus) {
     catch (error) {
         throwIfAborted(signal, error);
     }
+    if (fallback !== undefined)
+        return { value: fallback, runtime: false };
     try {
         const details = await postJson(`${at.baseUrl}/api/show`, headers(at), { model }, signal, onStatus);
         const capacity = modelCapacity(details);
@@ -118,6 +122,18 @@ async function nativeContextWindow(at, model, signal, onStatus) {
         return undefined;
     }
 }
+function cachedContext(cache, key) {
+    const cached = cache.get(key);
+    if (cached === undefined)
+        return undefined;
+    if (cached.expiresAt > Date.now())
+        return cached.value;
+    cache.delete(key);
+    return undefined;
+}
+function rememberContext(cache, key, value) {
+    cache.set(key, { value, expiresAt: Date.now() + CONTEXT_CACHE_MS });
+}
 function runningContext(value, model) {
     if (!record(value) || !Array.isArray(value["models"]))
         return undefined;

package/dist/sessions/store.js

@@ -16,6 +16,7 @@ const DIRECTORY_MODE = 0o700;
 const FILE_MODE = 0o600;
 const MAX_CATALOG_ENTRIES = 4_096;
 const CATALOG_READ_CONCURRENCY = 8;
+const NODE_READ_CONCURRENCY = 4;
 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$/;
@@ -296,17 +297,26 @@ async function readNodes(directory) {
     }
     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), SESSION_FILE_LIMITS.nodeBytes));
-        if (decoded.node.id !== id || sequences.has(decoded.sequence)) {
-            throw new Error("session conversation node identity is invalid");
+    for (let start = 0; start < names.length; start += NODE_READ_CONCURRENCY) {
+        const decoded = await Promise.all(names.slice(start, start + NODE_READ_CONCURRENCY)
+            .map(async (name, offset) => {
+            const id = Number(NODE_NAME.exec(name)?.[1]);
+            if (id !== start + offset + 1) {
+                throw new Error("session conversation nodes are not contiguous");
+            }
+            const entry = decodeNode(await readJson(path.join(directory, name), SESSION_FILE_LIMITS.nodeBytes));
+            if (entry.node.id !== id) {
+                throw new Error("session conversation node identity is invalid");
+            }
+            return entry;
+        }));
+        for (const entry of decoded) {
+            if (sequences.has(entry.sequence)) {
+                throw new Error("session conversation node identity is invalid");
+            }
+            sequences.add(entry.sequence);
+            stored.push(entry);
         }
-        sequences.add(decoded.sequence);
-        stored.push(decoded);
     }
     return stored;
 }

package/dist/tui/blocks.js

@@ -10,12 +10,11 @@ export function render(block, width, pal, context = {}) {
             return renderAnswer(block, width, pal);
         case "reasoning":
             return renderReasoning(block, width, pal, {
-                continues: context.previous?.kind === "tool" || context.previous?.kind === "reasoning",
+                continues: context.previous?.kind === "reasoning",
             });
         case "tool":
             return renderTool(block, width, pal, {
-                continues: context.previous?.kind === "tool" || context.previous?.kind === "reasoning",
-                followsReasoning: context.previous?.kind === "reasoning",
+                continues: context.previous?.kind === "tool",
                 now: context.now,
                 motion: context.motion,
                 reducedMotion: context.reducedMotion,

package/dist/tui/components/messages.js

@@ -1,5 +1,5 @@
 import { trailingText } from "../../text-boundary.js";
-import { row } from "../../ui/render.js";
+import { blank, row } from "../../ui/render.js";
 import { markdown } from "../../ui/markdown.js";
 import { transcriptLead, transcriptWidth } from "../transcript-grammar.js";
 export const REASONING_PREVIEW_ROWS = 3;
@@ -10,37 +10,34 @@ export function renderUser(block, width, pal) {
     const content = markdown(block.text, inner, pal, inner);
     return [
         "",
+        blank(width, pal.surface.subtle),
         ...content.map((line, index) => row(width, [
             ...transcriptLead(width, index === 0
                 ? { text: "❯", fg: pal.accent, bold: true }
                 : undefined),
             ...line.segs,
-        ])),
+        ], [], pal.surface.subtle)),
+        blank(width, pal.surface.subtle),
     ];
 }
 export function renderAnswer(block, width, pal) {
-    const inner = transcriptWidth(width);
     return [
         "",
-        ...markdown(block.text, inner, pal, inner).map((line) => row(width, [...transcriptLead(width), ...line.segs])),
+        ...markdown(block.text, width, pal, width).map((line) => row(width, line.segs)),
     ];
 }
 export function renderReasoning(block, width, pal, context = {}) {
-    const inner = transcriptWidth(width);
     // Expanding a live stream is deferred until it is sealed. Re-parsing an
     // ever-growing full thought on every token makes the whole TUI stall.
     const expanded = block.expanded === true && block.live !== true;
     const source = !expanded
-        ? reasoningPreviewSource(block.text, inner)
+        ? reasoningPreviewSource(block.text, width)
         : { text: block.text, truncated: false };
-    const content = markdown(source.text, inner, pal, inner);
+    const content = markdown(source.text, width, pal, width);
     const visible = expanded ? content : content.slice(-REASONING_PREVIEW_ROWS);
     return [
         ...(context.continues === true ? [] : [""]),
-        ...visible.map((line) => row(width, [
-            ...transcriptLead(width, { text: "│", fg: pal.rule }),
-            ...line.segs.map((seg) => ({ ...seg, fg: pal.ink.dim, italic: true })),
-        ])),
+        ...visible.map((line) => row(width, line.segs.map((seg) => ({ ...seg, fg: pal.ink.dim, italic: true })))),
     ];
 }
 export function reasoningPreviewSource(text, width) {

package/dist/tui/components/tool.js

@@ -3,8 +3,8 @@
 import { fitSegs, hasColor, plainLen, row } from "../../ui/render.js";
 import { graphemeCeiling, graphemeFloor } from "../../text-boundary.js";
 import { toolDuration } from "../../duration.js";
-import { breathe, easeInOut, easeOut, interval, mix, TOOL_BIRTH_MS, TOOL_LEADER_MAX_MS, TOOL_ROW_ARRIVAL_MS, TOOL_SETTLE_MS, } from "../motion.js";
-import { transcriptLead, transcriptMark } from "../transcript-grammar.js";
+import { breathe, easeInOut, easeOut, interval, mix, TOOL_BIRTH_MS, TOOL_LEADER_MAX_MS, TOOL_ROW_ARRIVAL_MS, } from "../motion.js";
+import { transcriptLead } from "../transcript-grammar.js";
 const OUTPUT_ROWS = 8;
 const LIVE_OUTPUT_ROWS = 6;
 const DIFF_ROWS = 15;
@@ -15,7 +15,7 @@ const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇",
 export function renderTool(block, width, pal, context = {}) {
     const now = context.now ?? Date.now();
     const shown = visibleDetails(block);
-    const ink = statusInk(block, pal, context, now);
+    const ink = stateInk(block, pal, context, now);
     const nameInk = birthInk(pal.ink.bright, pal.ink.dim, context, now);
     const left = [
         ...transcriptLead(width, { text: stateGlyph(block, context, now), fg: ink, bold: true }),
@@ -25,9 +25,7 @@ export function renderTool(block, width, pal, context = {}) {
     const right = resultSegments(block, pal, context, now);
     const leader = movingLeader(width, left, right, pal, context, now);
     return [
-        ...(context.followsReasoning === true
-            ? [row(width, transcriptMark(width, { text: "│", fg: pal.rule }))]
-            : context.continues === true ? [] : [""]),
+        ...(context.continues === true ? [] : [""]),
         row(width, leader === undefined ? left : [...left, leader], right),
         ...shown.map(({ detail, sourceIndex }) => renderDetail(detail, block.tone, width, pal, context.reducedMotion === true ? undefined : context.motion?.rowsAt[sourceIndex ?? -1], now)),
     ];
@@ -138,7 +136,7 @@ function stateGlyph(block, context, now) {
         return SPINNER[Math.floor(now / SPINNER_MS) % SPINNER.length] ?? "○";
     }
     if (block.tone === "fail")
-        return "×";
+        return hasColor() ? "●" : "×";
     if (block.tone === "deny")
         return "○";
     return hasColor() ? "●" : "✓";
@@ -148,7 +146,7 @@ function resultSegments(block, pal, context, now) {
     const duration = liveDuration(block, now);
     if (status === "" && duration === "")
         return [];
-    const ink = statusInk(block, pal, context, now);
+    const ink = resultInk(block, pal, context, now);
     return [
         ...(status === "" ? [] : [{ text: status, fg: ink }]),
         ...(duration === "" ? [] : [{ text: `${status === "" ? "" : " · "}${duration}`, fg: pal.ink.dim }]),
@@ -160,7 +158,7 @@ function liveDuration(block, now) {
     }
     return block.durationMs === undefined ? "" : toolDuration(block.durationMs);
 }
-function statusInk(block, pal, context, now) {
+function stateInk(block, pal, context, now) {
     if (block.tone === "fail")
         return pal.ink.removed;
     if (block.tone === "deny")
@@ -170,10 +168,10 @@ function statusInk(block, pal, context, now) {
             return pal.ink.attention;
         return mix(pal.ink.attention, pal.accent, breathe(now));
     }
-    if (context.reducedMotion === true || context.motion?.settledAt === undefined)
-        return pal.ink.muted;
-    const cooled = easeOut(interval(now, context.motion.settledAt, TOOL_SETTLE_MS));
-    return mix(pal.ink.added, pal.ink.muted, cooled);
+    return pal.ink.added;
+}
+function resultInk(block, pal, context, now) {
+    return block.tone === "ok" ? pal.ink.muted : stateInk(block, pal, context, now);
 }
 function birthInk(final, initial, context, now) {
     if (context.reducedMotion === true || context.motion === undefined)

package/dist/tui/transcript-grammar.js

@@ -1,9 +1,7 @@
-// One semantic margin shared by every transcript block.
-const FULL_GUTTER = 4;
-const COMPACT_GUTTER = 2;
-const COMPACT_BELOW = 64;
-export function transcriptGutter(width) {
-    return width < COMPACT_BELOW ? COMPACT_GUTTER : FULL_GUTTER;
+// One semantic margin shared by the user cue and executable tool evidence.
+const GUTTER = 2;
+export function transcriptGutter(_width) {
+    return GUTTER;
 }
 export function transcriptWidth(width) {
     return Math.max(8, width - transcriptGutter(width));
@@ -14,12 +12,10 @@ export function transcriptLead(width, mark) {
         return [{ text: " ".repeat(transcriptGutter(width)) }];
     return [
         ...transcriptMark(width, mark),
-        { text: " ".repeat(width < COMPACT_BELOW ? 1 : 2) },
+        { text: " " },
     ];
 }
 /** Draw only the gutter mark, without trailing content-column whitespace. */
-export function transcriptMark(width, mark) {
-    if (width < COMPACT_BELOW)
-        return [{ ...mark }];
-    return [{ text: " " }, { ...mark }];
+export function transcriptMark(_width, mark) {
+    return [{ ...mark }];
 }

package/dist/ui/inline.js

@@ -14,22 +14,22 @@ export function inline(text, base, pal, bold = false) {
     const { ink } = pal;
     const segs = [];
     let last = 0;
-    INLINE.lastIndex = 0;
-    for (let match = INLINE.exec(text); match !== null; match = INLINE.exec(text)) {
+    const matcher = new RegExp(INLINE.source, INLINE.flags);
+    for (let match = matcher.exec(text); match !== null; match = matcher.exec(text)) {
         if (match.index > last) {
             segs.push({ text: text.slice(last, match.index), fg: base, bold: bold || undefined });
         }
         const [, mono, strong, strongAlt, emphasis, label] = match;
         if (mono !== undefined)
-            segs.push({ text: mono, fg: pal.technical });
+            segs.push({ text: mono, fg: pal.technical, bold: bold || undefined });
         else if (strong !== undefined)
-            segs.push({ text: strong, fg: ink.bright, bold: true });
+            segs.push(...inline(strong, ink.bright, pal, true));
         else if (strongAlt !== undefined)
-            segs.push({ text: strongAlt, fg: ink.bright, bold: true });
+            segs.push(...inline(strongAlt, ink.bright, pal, true));
         else if (emphasis !== undefined)
-            segs.push({ text: emphasis, fg: ink.bright });
+            segs.push(...inline(emphasis, ink.bright, pal, bold));
         else if (label !== undefined)
-            segs.push({ text: label, fg: pal.technical });
+            segs.push({ text: label, fg: pal.technical, bold: bold || undefined });
         last = match.index + match[0].length;
     }
     if (last < text.length) {

package/dist/ui/theme.js

@@ -1,27 +1,27 @@
 // Jecode's fixed terminal identity. Components depend on semantic tokens, not
 // literal colours, while the product exposes one deliberate dark Slate look.
-// Jecode's fixed dark Slate baseline. The exported name stays stable while
-// cooler, quieter values leave the transcript bright enough to read and let
-// live state carry the colour.
+// Jecode's fixed dark Slate baseline. Clear text contrast and luminous
+// structural colours keep long terminal transcripts readable without making
+// live state decorative.
 // Components depend on these roles rather than embedding presentation values.
 export const STEEL = {
-    accent: [124, 164, 222],
-    technical: [126, 186, 208],
-    focus: [124, 164, 222],
-    rule: [44, 60, 78],
+    accent: [102, 155, 210],
+    technical: [78, 201, 232],
+    focus: [102, 155, 210],
+    rule: [53, 80, 110],
     ink: {
-        fg: [214, 219, 226],
-        bright: [241, 244, 248],
-        muted: [149, 160, 174],
-        dim: [99, 111, 125],
-        attention: [226, 188, 112],
-        added: [138, 190, 150],
-        removed: [223, 120, 120],
+        fg: [220, 224, 229],
+        bright: [235, 239, 244],
+        muted: [156, 169, 183],
+        dim: [112, 124, 137],
+        attention: [230, 191, 95],
+        added: [134, 203, 146],
+        removed: [232, 112, 112],
     },
     surface: {
-        subtle: [23, 29, 37],
-        added: [21, 52, 33],
-        removed: [58, 24, 27],
-        attention: [58, 47, 20],
+        subtle: [31, 38, 47],
+        added: [22, 55, 34],
+        removed: [62, 24, 27],
+        attention: [62, 50, 19],
     },
 };

package/package.json

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