kritya 0.8.32-beta → 0.8.33-beta

package/README.md

@@ -124,7 +124,8 @@ kritya               # enter
 kritya [directory] [options]
 
   -c, --continue        resume the most recent session for this directory
-  -r, --resume          pick a past session from a list
+  -r, --resume [name]   list past sessions, or resume one by its short name
+                        (e.g. `kritya -r a3f9k2`; plain `-r` opens the list)
   -m, --model <id>      use any model ID your provider offers
   -p, --provider <name> nvidia (default), openai, openrouter, groq, deepseek,
                         mistral, together, ollama, switchyard (multi-model

package/dist/crash.js

@@ -95,6 +95,15 @@ export function installCrashHandlers(opts) {
     process.on("uncaughtException", (err) => onCrash(err, "uncaught exception"));
     process.on("unhandledRejection", (reason) => onCrash(reason, "unhandled rejection"));
 }
+/**
+ * True while the crash path is running. The crash report already tells the user
+ * where the transcript is and how to resume, so anything that would print its
+ * own sign-off on the way out (the interactive exit notice) checks this first
+ * and stays quiet rather than saying it twice, in two different formats.
+ */
+export function isHandlingCrash() {
+    return handling;
+}
 /** Test seam: forget that handlers were installed. */
 export function resetCrashHandlersForTest() {
     installed = false;

package/dist/index.js

@@ -11,7 +11,8 @@ import { loadRules } from "./permissions/rules.js";
 import { ProviderClient } from "./provider/client.js";
 import { createSwitchyardClient } from "./provider/switchyardClient.js";
 import { SWITCHYARD_ROUTE_ID, resolveEffectiveModel, staleSwitchyardModelWarning, } from "./provider/switchyardSidecar.js";
-import { SessionStore } from "./session/store.js";
+import { SessionStore, shortSessionId } from "./session/store.js";
+import { exitNotice } from "./session/exitNotice.js";
 import { AuditLog } from "./audit/audit.js";
 import { runAuditCli } from "./audit/cli.js";
 import { runSkillsCli } from "./agent/skillsCli.js";
@@ -39,7 +40,7 @@ import { isAiDisclosureShown, markAiDisclosureShown } from "./trust/aiDisclosure
 import { isBannerSeen, markBannerSeen } from "./trust/bannerSeen.js";
 import { partitionByTrust, serverFingerprint, trustServer } from "./trust/mcpTrust.js";
 import { runHeadless } from "./headless.js";
-import { installCrashHandlers } from "./crash.js";
+import { installCrashHandlers, isHandlingCrash } from "./crash.js";
 import { createSubagentRunner } from "./agent/subagents.js";
 import { VERSION } from "./version.js";
 import { updateNoticeForUser } from "./update/check.js";
@@ -49,7 +50,8 @@ Usage: kritya [directory] [options]
 
 Options:
   -c, --continue      resume the most recent session for this directory
-  -r, --resume        pick a past session for this directory from a list
+  -r, --resume [name] list past sessions, or resume one by its short name
+                      (e.g. kritya -r a3f9k2; plain -r opens the picker)
   -m, --model <id>    model ID to use (any model your provider offers)
   -p, --provider <n>  provider: nvidia (default), openai, openrouter, groq,
                       deepseek, mistral, together, ollama, or a custom one
@@ -88,11 +90,34 @@ Setup:
   3. cd your-project && kritya .
 
 Config file: ~/.kritya/config.json  { "apiKey", "model", "customModels": [{"id"}] }`;
+/** True if `p` names an existing directory — used to keep `-r <dir>` unambiguous. */
+function isDirectory(p) {
+    try {
+        return fs.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Write the exit notice to stdout. Best-effort: this runs from an "exit"
+ * handler, where the stream may already be gone, and there is nowhere left to
+ * report that if it is.
+ */
+function writeExitNotice(text) {
+    try {
+        process.stdout.write(text + "\n");
+    }
+    catch {
+        // Nothing left to write to.
+    }
+}
 function parseArgs(argv) {
     const args = {
         dir: ".",
         continue: false,
         resume: false,
+        resumeName: "",
         model: "",
         provider: "",
         help: false,
@@ -108,8 +133,23 @@ function parseArgs(argv) {
         const a = argv[i];
         if (a === "-c" || a === "--continue")
             args.continue = true;
-        else if (a === "-r" || a === "--resume")
+        else if (a === "-r" || a === "--resume") {
+            args.resume = true;
+            // `-r <name>` resumes one session directly; a bare `--resume` opens the
+            // picker. The value is only consumed when it cannot be the directory
+            // positional — `kritya -r some-dir` is the documented way to open a
+            // project, so an existing directory always wins. When the name really is
+            // an existing directory, `--resume=<name>` still forces it through.
+            const next = argv[i + 1];
+            if (next && !next.startsWith("-") && !isDirectory(next)) {
+                args.resumeName = next;
+                i++;
+            }
+        }
+        else if (a.startsWith("--resume=")) {
             args.resume = true;
+            args.resumeName = a.slice("--resume=".length);
+        }
         else if (a === "-m" || a === "--model")
             args.model = argv[++i] ?? "";
         else if (a === "-p" || a === "--provider")
@@ -390,10 +430,60 @@ async function main() {
     const sessionMeter = privacyMode
         ? createMeter(session.id, "off")
         : createMeter(session.id, config.otel);
-    const initialHistory = !privacyMode && args.continue ? (SessionStore.loadLatest(workspace) ?? []) : [];
-    const initialTasks = !privacyMode && args.continue ? SessionStore.loadLatestTasks(workspace) : [];
+    // `-r <name>` is resolved before the session file is opened, so a typo fails
+    // fast with a clear message instead of silently starting an empty session.
+    // Precedence is named resume > -c > a fresh session.
+    let resumedFile;
+    if (!privacyMode && args.resumeName) {
+        const found = SessionStore.resolveSession(workspace, args.resumeName);
+        if ("error" in found) {
+            console.error(found.error);
+            process.exit(1);
+        }
+        resumedFile = found.file;
+    }
+    let initialHistory = [];
+    let initialTasks = [];
+    if (!privacyMode) {
+        if (resumedFile) {
+            initialHistory = SessionStore.loadFile(resumedFile);
+            initialTasks = SessionStore.loadTasksForSession(resumedFile);
+        }
+        else if (args.continue) {
+            initialHistory = SessionStore.loadLatest(workspace) ?? [];
+            initialTasks = SessionStore.loadLatestTasks(workspace);
+        }
+    }
     session.start(initialHistory);
-    const resumeSessions = !privacyMode && args.resume ? SessionStore.listSessions(workspace) : [];
+    // The picker only opens when no session was named — `-r a3f9k2` has already
+    // decided which conversation to open.
+    const resumeSessions = !privacyMode && args.resume && !resumedFile ? SessionStore.listSessions(workspace) : [];
+    // Where the conversation went, said once on the way out. This is the last
+    // thing on screen and the only place the session's short name is discoverable
+    // without re-running --resume, so it is worth printing rather than leaving
+    // the user to guess. Registered on "exit" rather than drawn as a transcript
+    // item so it covers every way out — Ctrl+C and a real signal included, not
+    // just /exit. The crash handler prints its own version of this, so it is
+    // skipped there rather than said twice in two formats.
+    let farewellPrinted = false;
+    const printFarewell = () => {
+        if (farewellPrinted || isHandlingCrash())
+            return;
+        farewellPrinted = true;
+        const file = session.path;
+        const text = exitNotice({
+            privacyMode,
+            messageCount: session.messageCount,
+            // A count with no file on disk means persistence failed somewhere along
+            // the way — don't promise a resume that cannot work.
+            file: file && fs.existsSync(file) ? file : undefined,
+            workspace,
+            cwd: process.cwd(),
+            isTTY: Boolean(process.stdout.isTTY),
+        });
+        if (text)
+            writeExitNotice(text);
+    };
     // Filled in once the app is mounted, below; the crash handler needs a way to
     // tear the UI down and is installed before there is a UI to tear down.
     const ui = {};
@@ -409,6 +499,10 @@ async function main() {
     // resort fallback path stays on the synchronous, fire-and-forget flush()
     // inside cleanup() — it's best-effort only, not guaranteed to land.
     process.on("exit", cleanup);
+    // Registered after cleanup so the sign-off really is the last thing printed:
+    // cleanup kills background servers and MCP children, and anything they write
+    // to stderr on the way down would otherwise land after it.
+    process.on("exit", printFarewell);
     // Same reasoning as the signal handlers below, for the other way the process
     // can die without firing "exit": an error nothing caught. Also hands the
     // terminal back — Ink leaves it in raw mode with the cursor hidden.
@@ -418,9 +512,14 @@ async function main() {
         unmountUi: () => ui.instance?.unmount(),
         details: () => {
             const file = session.path;
-            return file
-                ? ["", `The conversation was saved to ${file}`, `Resume it with:  kritya -c ${workspace}`]
-                : [];
+            if (!file)
+                return [];
+            const where = workspace === process.cwd() ? "" : ` ${workspace}`;
+            return [
+                "",
+                `The conversation was saved to ${file}`,
+                `Resume it with:  kritya -r ${shortSessionId(file)}${where}`,
+            ];
         },
     });
     // Default signal handling terminates WITHOUT firing "exit", which would
@@ -608,7 +707,7 @@ async function main() {
     // `renderTime` excludes Ink's own throttling, so it is the raw cost of the
     // frame rather than the interval between frames.
     const renderHistogram = sessionMeter.histogram("kritya.render.duration_ms", RENDER_BOUNDS_MS);
-    ui.instance = render(_jsx(App, { agent: agent, workspace: workspace, modelRef: modelRef, providerRef: providerRef, config: config, resumedCount: initialHistory.length, initialTasks: initialTasks, undoStack: undoStack, uiBridge: uiBridge, resumeSessions: resumeSessions.length ? resumeSessions : undefined, customCommands: loadCustomCommands(workspace, trustWorkspace, plugins), mcpToolCount: mcpTools.length, onSwitchClient: (newClient) => {
+    ui.instance = render(_jsx(App, { agent: agent, workspace: workspace, modelRef: modelRef, providerRef: providerRef, config: config, resumedCount: initialHistory.length, resumedName: resumedFile ? shortSessionId(resumedFile) : undefined, initialTasks: initialTasks, undoStack: undoStack, uiBridge: uiBridge, resumeSessions: resumeSessions.length ? resumeSessions : undefined, customCommands: loadCustomCommands(workspace, trustWorkspace, plugins), mcpToolCount: mcpTools.length, onSwitchClient: (newClient) => {
             client = newClient;
         }, onRequestPermissionReady: (fn) => {
             permissionRef.current = fn;

package/dist/session/exitNotice.js

@@ -0,0 +1,30 @@
+import { shortSessionId } from "./store.js";
+/**
+ * The sign-off printed when an interactive session ends, or null when there is
+ * nothing worth saying.
+ *
+ * This is the only place the session's short name is discoverable without
+ * re-running `--resume`, so it is the whole point of the feature: quit, and the
+ * terminal tells you the exact command that brings this conversation back.
+ *
+ * Pulled out of the CLI entry point as a pure function on purpose. It is the
+ * one piece of the exit path with real logic — privacy mode, an empty session,
+ * singular/plural, and whether the resume command even works from here — and
+ * `index.tsx` is excluded from coverage, so anything left in there is logic
+ * nothing measures.
+ */
+export function exitNotice(input) {
+    if (input.privacyMode)
+        return "Session not saved (--privacy).";
+    if (!input.file || input.messageCount <= 0)
+        return null;
+    const dim = input.isTTY ? "\x1b[2m" : "";
+    const plain = input.isTTY ? "\x1b[22m" : "";
+    const n = input.messageCount;
+    // `kritya -r <code>` only resolves from the directory the session belongs to,
+    // so say where that was when it is not where the user is standing.
+    const where = input.workspace === input.cwd ? "" : ` ${input.workspace}`;
+    return (`${dim}Session saved · ${n} message${n === 1 ? "" : "s"}${plain}\n` +
+        `${dim}  resume  ${plain}kritya -r ${shortSessionId(input.file)}${where}\n` +
+        `${dim}  list    ${plain}kritya -r`);
+}

package/dist/session/store.js

@@ -58,6 +58,29 @@ function sessionDir(workspace) {
     const hash = crypto.createHash("sha1").update(workspace).digest("hex").slice(0, 12);
     return path.join(CONFIG_DIR, "sessions", hash);
 }
+/**
+ * Short, typeable handle for a session — a 5-character base36 code derived
+ * deterministically from the transcript's filename.
+ *
+ * The full id (the ISO timestamp basename) stays the on-disk name and the key
+ * that correlates the audit log and telemetry spans, and nothing here changes
+ * that. This is only what the user reads and retypes: `2026-10-06T19-08-39-123Z`
+ * is not a thing anyone types twice, which is why the exit notice and the
+ * `--resume` picker both show this instead.
+ *
+ * Derived rather than stored on purpose — there is no index file to drift out
+ * of sync with the directory, and the code is stable for the life of the
+ * transcript. Uniqueness is therefore *checked* at lookup time rather than
+ * assumed: see resolveSession(), which reports an ambiguous prefix instead of
+ * silently opening the wrong conversation.
+ */
+export function shortSessionId(file) {
+    const name = path.basename(file, ".jsonl");
+    const digest = crypto.createHash("sha1").update(name).digest();
+    // Low-order base36 digits, so the code is uniformly distributed over the
+    // alphabet rather than clustered by the timestamp's shared prefix.
+    return digest.readUInt32BE(0).toString(36).padStart(5, "0").slice(-5);
+}
 /**
  * Transcripts can contain secrets that passed through tool output, so they are
  * always written 0o600 rather than inheriting whatever mode the file had.
@@ -76,12 +99,23 @@ export class SessionStore {
     ephemeral;
     dir;
     file;
+    /**
+     * Messages persisted to the current file so far. Tracked in memory rather
+     * than re-read from disk because the exit notice needs it after the process
+     * has already begun tearing down, where reading back a possibly 50 MB
+     * transcript would be both slow and pointless.
+     */
+    count = 0;
     /** When ephemeral, nothing is persisted to disk (used by subagents). */
     constructor(workspace, ephemeral = false) {
         this.ephemeral = ephemeral;
         this.dir = sessionDir(workspace);
         this.file = this.newFilePath();
     }
+    /** How many messages this session has written. 0 means nothing is on disk yet. */
+    get messageCount() {
+        return this.count;
+    }
     newFilePath() {
         const stamp = new Date().toISOString().replace(/[:.]/g, "-");
         return path.join(this.dir, `${stamp}.jsonl`);
@@ -157,6 +191,7 @@ export class SessionStore {
         if (seed.length) {
             writeSessionFile(this.file, seed.map((m) => JSON.stringify(capMessageContent(m)) + "\n").join(""));
         }
+        this.count = seed.length;
     }
     /**
      * Appends one JSON-encoded message per call — a crash mid-write can only
@@ -175,6 +210,7 @@ export class SessionStore {
             fs.appendFileSync(this.file, JSON.stringify(capMessageContent(message)) + "\n", {
                 mode: 0o600,
             });
+            this.count++;
         }
         catch (err) {
             // Persistence is best-effort; never crash the session over it.
@@ -184,6 +220,7 @@ export class SessionStore {
     /** Start over with a fresh session file (used by /clear). */
     rotate() {
         this.file = this.newFilePath();
+        this.count = 0;
     }
     /**
      * Rewrite the session file to hold exactly `messages`, atomically. The log
@@ -198,6 +235,7 @@ export class SessionStore {
             fs.mkdirSync(this.dir, { recursive: true, mode: 0o700 });
             hardenWindowsDir(CONFIG_DIR);
             writeSessionFile(this.file, messages.map((m) => JSON.stringify(capMessageContent(m)) + "\n").join(""));
+            this.count = messages.length;
         }
         catch (err) {
             // Persistence is best-effort; never crash the session over it.
@@ -252,6 +290,63 @@ export class SessionStore {
             return false;
         }
     }
+    /**
+     * Turn a user-typed session handle into a transcript file.
+     *
+     * Accepts the short code shown by the exit notice and the `--resume` picker,
+     * or the full timestamp basename, or any unambiguous prefix of either — the
+     * whole point is that the user can retype something short. Deliberately
+     * searches the entire directory rather than listSessions()' display window of
+     * 20, so a code copied from an earlier exit notice still resolves.
+     *
+     * Returns an error string instead of throwing so the CLI can print it and
+     * exit(1) without the caller having to distinguish "no such session" from
+     * "ambiguous" itself.
+     */
+    static resolveSession(workspace, name) {
+        const query = name.trim().toLowerCase();
+        if (!query)
+            return { error: "No session name given." };
+        const dir = sessionDir(workspace);
+        let entries;
+        try {
+            entries = fs.readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+        }
+        catch {
+            return { error: "No saved sessions for this directory yet." };
+        }
+        if (!entries.length)
+            return { error: "No saved sessions for this directory yet." };
+        // Keyed by file, not appended to a list: a query can prefix both a
+        // transcript's short code *and* its timestamp basename (every basename
+        // starts with the year), and counting that file twice would report a
+        // perfectly unambiguous name as ambiguous.
+        const matches = new Map();
+        for (const entry of entries) {
+            const file = path.join(dir, entry);
+            // Same containment check the IPC path uses — a symlink dropped into the
+            // session directory must not turn `--resume <name>` into an arbitrary
+            // file read.
+            if (!SessionStore.isSessionFile(workspace, file))
+                continue;
+            const base = path.basename(entry, ".jsonl").toLowerCase();
+            const short = shortSessionId(file);
+            if (short.startsWith(query) || base.startsWith(query))
+                matches.set(file, short);
+        }
+        if (!matches.size) {
+            return {
+                error: `No session matching "${name}" in this directory. Run \`kritya -r\` to list them.`,
+            };
+        }
+        if (matches.size > 1) {
+            const codes = [...matches.values()].join(", ");
+            return {
+                error: `"${name}" matches ${matches.size} sessions (${codes}) — use more characters.`,
+            };
+        }
+        return { file: [...matches.keys()][0] };
+    }
     static loadFile(filePath) {
         const messages = [];
         let raw;
@@ -404,7 +499,14 @@ export class SessionStore {
             catch {
                 // leave empty
             }
-            sessions.push({ file, date, preview, title, count: lines.length });
+            sessions.push({
+                file,
+                date,
+                preview,
+                title,
+                shortId: shortSessionId(file),
+                count: lines.length,
+            });
         }
         return sessions;
     }

package/dist/ui/App.js

@@ -30,7 +30,7 @@ const MENTION_RE = /(^|\s)@([^\s@]*)$/;
 const MENTION_ALL_RE = /(?:^|\s)@([^\s@]+)/g;
 const MAX_MENTION_CHARS = 8000;
 const IMAGE_RE = /\.(png|jpe?g|gif|webp|bmp)$/i;
-export function App({ agent, workspace, modelRef, providerRef, config, resumedCount, initialTasks, undoStack, uiBridge, resumeSessions, customCommands = [], mcpToolCount = 0, onSwitchClient, onRequestPermissionReady, onRequestElicitationReady, privacyMode, firstLaunch, }) {
+export function App({ agent, workspace, modelRef, providerRef, config, resumedCount, resumedName, initialTasks, undoStack, uiBridge, resumeSessions, customCommands = [], mcpToolCount = 0, onSwitchClient, onRequestPermissionReady, onRequestElicitationReady, privacyMode, firstLaunch, }) {
     const { exit, suspendTerminal, waitUntilRenderFlush } = useApp();
     /**
      * Leave, but not until the screen has caught up.
@@ -119,6 +119,7 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
         config,
         uiBridge,
         resumedCount,
+        resumedName,
         initialTasks,
         resumeSessions,
         refreshFileList,
@@ -505,13 +506,13 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
                                 }, placeholder: "steer the agent\u2026 (Enter to queue)" })] })] })), phase === "permission" && permission && (_jsx(PermissionPrompt, { toolName: permission.toolName, summary: permission.summary, diff: permission.diff, warning: permission.warning, onDecision: onPermissionDecision })), phase === "elicitation" && elicitation && (_jsx(ElicitationPrompt, { message: elicitation.message, fields: elicitation.fields, onDecision: onElicitationDecision })), phase === "confirmMode" && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "green", paddingX: 1, children: [_jsx(Text, { bold: true, color: "green", children: "Switch to accept-edits mode?" }), _jsx(Text, { children: "File writes and edits will auto-approve without asking." }), _jsx(Text, { dimColor: true, children: "Destructive shell commands (rm -rf, force-push, etc.) always still ask, in every mode." }), _jsx(Text, { dimColor: true, children: "Shift+Tab again moves to dry-run mode; once more back to normal." }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: [_jsx(Text, { color: "green", children: "Yes (y)" }), " \u00B7 No (n/Esc)"] }) })] })), phase === "confirmBypassMode" && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "red", paddingX: 1, children: [_jsx(Text, { bold: true, color: "red", children: "Switch to auto mode? (sandbox-gated)" }), _jsx(Text, { children: "EVERY tool call will auto-approve, including destructive shell commands (rm -rf, force-push, etc.) \u2014 nothing will ask first." }), _jsx(Text, { dimColor: true, children: "The sandbox \u2014 not a human \u2014 is what contains any damage this mode causes." }), _jsx(Text, { dimColor: true, children: "Shift+Tab again goes back to normal." }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: [_jsx(Text, { color: "red", children: "Yes (y)" }), " \u00B7 No (n/Esc)"] }) })] })), phase === "model" && (_jsx(ModelPicker, { current: model, customModels: config.customModels ?? [], onSelect: (id) => {
                     setPhase("input");
                     setModelEverywhere(id);
-                }, onCancel: () => setPhase("input") })), phase === "resume" && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "magenta", paddingX: 1, children: [_jsxs(Text, { bold: true, color: "magenta", children: ["Resume a session ", _jsx(Text, { dimColor: true, children: "(type to search \u00B7 Esc for a fresh one)" })] }), resumeFilter ? (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "filter: " }), resumeFilter] })) : null, _jsx(SelectList, { items: (resumeSessions ?? [])
+                }, onCancel: () => setPhase("input") })), phase === "resume" && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "magenta", paddingX: 1, children: [_jsxs(Text, { bold: true, color: "magenta", children: ["Resume a session", " ", _jsx(Text, { dimColor: true, children: "(type to search \u00B7 Esc for a fresh one \u00B7 -r <code> to skip this)" })] }), resumeFilter ? (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "filter: " }), resumeFilter] })) : null, _jsx(SelectList, { items: (resumeSessions ?? [])
                             .filter((s) => s.title.toLowerCase().includes(resumeFilter.toLowerCase()) ||
                             SessionStore.matchesContent(s.file, resumeFilter))
                             .map((s) => ({
                             label: s.title,
                             value: s.file,
-                            hint: `${s.date} · ${s.count} msgs`,
+                            hint: `${s.shortId} · ${s.date} · ${s.count} msgs`,
                         })), onSelect: onResumeSelect, onCancel: () => onResumeSelect("") })] })), phase === "input" && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, children: [_jsx(Text, { color: "green", children: "\u276F " }), _jsx(TextInput, { value: input, onChange: (v) => {
                                     setInput(v.replace(/\t/g, ""));
                                     setCmdIndex(0);

package/dist/ui/useAgent.js

@@ -45,7 +45,7 @@ function initialToolStatus(name) {
  * permission state, usage/cost tracking, and session resume. Input handling
  * (text box, slash-command suggestions, @mention autocomplete) stays in App.
  */
-export function useAgent({ agent, workspace, modelRef, providerRef, config, uiBridge, resumedCount, initialTasks, resumeSessions, refreshFileList, onSwitchClient, }) {
+export function useAgent({ agent, workspace, modelRef, providerRef, config, uiBridge, resumedCount, resumedName, initialTasks, resumeSessions, refreshFileList, onSwitchClient, }) {
     const nextId = useRef(0);
     const [items, setItems] = useState(() => {
         const initial = [
@@ -64,7 +64,9 @@ export function useAgent({ agent, workspace, modelRef, providerRef, config, uiBr
             initial.push({
                 id: nextId.current++,
                 kind: "info",
-                text: `Resumed previous session (${resumedCount} messages)${taskNote}.`,
+                text: resumedName
+                    ? `Resumed session ${resumedName} (${resumedCount} messages)${taskNote}.`
+                    : `Resumed previous session (${resumedCount} messages)${taskNote}.`,
             });
         }
         return initial;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kritya",
-  "version": "0.8.32-beta",
+  "version": "0.8.33-beta",
   "description": "Kritya — Superintelligence at your command line",
   "type": "module",
   "publishConfig": {