kritya 0.8.32-beta → 0.8.34-beta

package/README.md

@@ -124,7 +124,9 @@ 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 auto-derived
+                        name (e.g. `kritya -r fix-login-bug`) or 5-character
+                        code; 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

@@ -12,6 +12,7 @@ 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 { 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,9 @@ 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 auto-derived
+                      name (e.g. kritya -r fix-login-bug) or 5-character code;
+                      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 +91,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 +134,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 +431,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 +500,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 +513,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 ${SessionStore.displayName(file)}${where}`,
+            ];
         },
     });
     // Default signal handling terminates WITHOUT firing "exit", which would
@@ -608,7 +708,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 ? SessionStore.displayName(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 { SessionStore } 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 ${SessionStore.displayName(input.file)}${where}\n` +
+        `${dim}  list    ${plain}kritya -r`);
+}

package/dist/session/store.js

@@ -58,6 +58,77 @@ 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);
+}
+/**
+ * Turn a first user message into a short, typeable session name:
+ * "Fix the login bug!!" -> "fix-the-login-bug". Lowercase, runs of
+ * non-alphanumerics become one hyphen, capped at 40 characters so the name
+ * stays something a person will actually retype. Returns "" when nothing
+ * usable remains (empty input, only punctuation).
+ */
+export function slugifySessionName(text) {
+    const slug = text
+        .slice(0, 80)
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 40)
+        .replace(/-+$/g, "");
+    return slug;
+}
+/**
+ * Pull plain text out of a message for naming/preview purposes. Content can
+ * be a string, an array of content parts (text + images), or null — images
+ * contribute nothing to a name.
+ */
+function messageText(message) {
+    const content = message.content;
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .filter((p) => p.type === "text")
+            .map((p) => p.text)
+            .join(" ");
+    }
+    return "";
+}
+/**
+ * The first message that may name a session: a real user message, not one of
+ * the synthetic "[...]" notes the agent writes to itself (undo, summaries).
+ * Mirrors the filter listSessions() uses for its preview, so the name and
+ * the preview always agree about what the conversation is about.
+ */
+function nameableText(message) {
+    if (message.role !== "user")
+        return undefined;
+    const text = messageText(message).replace(/\s+/g, " ").trim();
+    if (!text || text.startsWith("["))
+        return undefined;
+    return text;
+}
 /**
  * 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 +147,56 @@ 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;
+    }
+    /**
+     * Whether this file's name is settled — either a sidecar already exists
+     * (written earlier, or by a previous process) or we just wrote one.
+     * Reset by rotate(), which starts a new file that deserves its own name.
+     */
+    nameResolved = false;
+    /**
+     * Name this session from its first real user message, once. Later messages
+     * never rename it: the name is meant to stay stable so `-r <name>` keeps
+     * working and the resume list doesn't shift under the user.
+     */
+    maybeNameSession(message) {
+        if (this.nameResolved || this.ephemeral)
+            return;
+        if (SessionStore.readName(this.file)) {
+            this.nameResolved = true;
+            return;
+        }
+        const text = nameableText(message);
+        if (!text)
+            return;
+        const slug = slugifySessionName(text);
+        if (!slug)
+            return;
+        try {
+            writeSessionFile(SessionStore.nameFilePathFor(this.file), slug + "\n");
+            this.nameResolved = true;
+        }
+        catch (err) {
+            // Naming is cosmetic; never fail a turn over it.
+            debugLog(`SessionStore.maybeNameSession(${this.file})`, err);
+        }
+    }
     newFilePath() {
         const stamp = new Date().toISOString().replace(/[:.]/g, "-");
         return path.join(this.dir, `${stamp}.jsonl`);
@@ -109,6 +224,35 @@ export class SessionStore {
     static tasksFilePathFor(sessionFile) {
         return sessionFile.replace(/\.jsonl$/, ".tasks.json");
     }
+    /**
+     * Sidecar holding the session's human-readable name (see
+     * slugifySessionName), written once from the first real user message.
+     * A sidecar rather than a rename: the transcript filename is the session's
+     * stable id for audit/telemetry correlation, and renaming it mid-session
+     * would churn that id plus the tasks sidecar that keys off it.
+     */
+    static nameFilePathFor(sessionFile) {
+        return sessionFile.replace(/\.jsonl$/, ".name");
+    }
+    /** The auto-derived name for a session file, if it earned one yet. */
+    static readName(sessionFile) {
+        try {
+            const name = fs.readFileSync(SessionStore.nameFilePathFor(sessionFile), "utf8").trim();
+            return name || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * What the user types and sees: the auto-derived name when the session has
+     * one, otherwise the short hash code. Every surface that names a session —
+     * the exit notice, the crash report, the `--resume` picker, `-r <name>` —
+     * goes through here so they can never disagree.
+     */
+    static displayName(sessionFile) {
+        return SessionStore.readName(sessionFile) ?? shortSessionId(sessionFile);
+    }
     /**
      * Persists the current task checklist alongside the session, so `-c`/`-r`
      * can restore not just the conversation but what was done vs. pending.
@@ -157,6 +301,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 +320,8 @@ export class SessionStore {
             fs.appendFileSync(this.file, JSON.stringify(capMessageContent(message)) + "\n", {
                 mode: 0o600,
             });
+            this.count++;
+            this.maybeNameSession(message);
         }
         catch (err) {
             // Persistence is best-effort; never crash the session over it.
@@ -184,6 +331,9 @@ export class SessionStore {
     /** Start over with a fresh session file (used by /clear). */
     rotate() {
         this.file = this.newFilePath();
+        this.count = 0;
+        // The new file deserves its own name, from its own first message.
+        this.nameResolved = false;
     }
     /**
      * Rewrite the session file to hold exactly `messages`, atomically. The log
@@ -198,6 +348,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 +403,66 @@ 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);
+            const slug = SessionStore.readName(file)?.toLowerCase();
+            if (short.startsWith(query) ||
+                base.startsWith(query) ||
+                (slug !== undefined && (slug === query || slug.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;
@@ -337,6 +548,7 @@ export class SessionStore {
                     if (fs.statSync(file).mtimeMs < cutoff) {
                         fs.unlinkSync(file);
                         fs.rmSync(SessionStore.tasksFilePathFor(file), { force: true });
+                        fs.rmSync(SessionStore.nameFilePathFor(file), { force: true });
                     }
                 }
                 catch (err) {
@@ -404,7 +616,15 @@ export class SessionStore {
             catch {
                 // leave empty
             }
-            sessions.push({ file, date, preview, title, count: lines.length });
+            sessions.push({
+                file,
+                date,
+                preview,
+                title,
+                name: SessionStore.readName(file) ?? "",
+                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,17 @@ 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 ?? [])
-                            .filter((s) => s.title.toLowerCase().includes(resumeFilter.toLowerCase()) ||
-                            SessionStore.matchesContent(s.file, resumeFilter))
+                }, 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 <name> to skip this)" })] }), resumeFilter ? (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "filter: " }), resumeFilter] })) : null, _jsx(SelectList, { items: (resumeSessions ?? [])
+                            .filter((s) => {
+                            const f = resumeFilter.toLowerCase();
+                            return (s.title.toLowerCase().includes(f) ||
+                                s.name.toLowerCase().includes(f) ||
+                                SessionStore.matchesContent(s.file, resumeFilter));
+                        })
                             .map((s) => ({
-                            label: s.title,
+                            label: s.name || 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.34-beta",
   "description": "Kritya — Superintelligence at your command line",
   "type": "module",
   "publishConfig": {