aegis-desktop 0.8.23 → 0.8.26

package/lib/local/engine.js

@@ -95,6 +95,30 @@ try {
   }
 }
 
+/**
+ * The module that decides where this install's data directory IS
+ * (`$AEGISCODE_HOME`, else `~/.aegiscode`) — the same two-layout resolution as
+ * `platformLib` above, and for the same reason: the environment block must
+ * state the path this machine actually writes, not a path this file guessed.
+ *
+ * Reported live (DeepSeek, Windows, 2026-10-04): asked to check the AEGIS data
+ * directory, the model produced `C:\Users\Dator.aegiscode` — the home directory
+ * with the separator EATEN — and then ran
+ * `Get-ChildItem -Filter aegis -Recurse -Depth 2` over the whole profile when
+ * that path came back empty. Nothing in the prompt had ever named the real
+ * directory, so building it from the home directory was the only move it had.
+ */
+let credentialsLib = null;
+try {
+  credentialsLib = require('../../../client/credentials.js');
+} catch {
+  try {
+    credentialsLib = require('../../vendor/credentials.js');
+  } catch {
+    credentialsLib = null;
+  }
+}
+
 /**
  * The environment facts the model needs to stop asking which OS it is on.
  *
@@ -167,11 +191,54 @@ function hostEnv(base = {}, supplied = {}, payload = null) {
   } catch {
     /* no desktop line */
   }
+  // The data directory (`$AEGISCODE_HOME`, else `~/.aegiscode`), read from the
+  // module every host already resolves it through. Stated rather than left to
+  // be built from `homedir`: a model that concatenates home + ".aegiscode"
+  // itself is one dropped separator away from `Dator.aegiscode`, a path that
+  // does not exist, and it has no way to tell the difference from the answer.
+  let dataDir = b.dataDir;
+  try {
+    if (!dataDir && credentialsLib) dataDir = credentialsLib.aegisHome();
+  } catch {
+    /* no data-directory line */
+  }
+  // The user's own locale, from the module that already resolves home and
+  // Desktop (client/platform.js appLocale). Stated for the same reason the
+  // Desktop path is: it is a fact about THIS machine that the model cannot
+  // derive from `platform: win32`, and until it is stated the model mirrors
+  // whatever language the message arrived in and defaults to the prompt's
+  // English otherwise — so a Swedish user had no way to stop being greeted in
+  // English, and a one-word request ("städa") had no language to be read in.
+  // Best-effort: a failed probe simply omits the line.
+  let locale = b.locale;
+  let localeName = b.localeName;
+  try {
+    if (!locale && platformLib && typeof platformLib.appLocale === 'function') {
+      locale = platformLib.appLocale();
+    }
+    if (locale && !localeName && platformLib && typeof platformLib.languageName === 'function') {
+      localeName = platformLib.languageName(locale);
+    }
+  } catch {
+    /* no locale line */
+  }
   return {
     platform: pick('platform', b.platform || process.platform),
     arch: pick('arch', b.arch || process.arch),
     homedir: pick('homedir', homedir),
     desktopdir: pick('desktopdir', desktopdir),
+    dataDir: pick('dataDir', dataDir),
+    locale: pick('locale', locale),
+    localeName: pick('localeName', localeName),
+    // Durable language EVIDENCE, which is a different thing from `locale` and is
+    // passed through rather than probed: `locale` is where the machine is set
+    // up, this is what the holder's own saved writing is in. A host that has
+    // folded the avatar profile (lib/avatar/profile.js foldLanguage, which
+    // already emits "writes durably in Swedish (sv), so reply in Swedish unless
+    // asked otherwise") hands the facets in here; a host with no avatar passes
+    // nothing and gets the exact pre-locale turn. Shapes: a `{ code, name }`,
+    // a `{ key, value }` facet, or a bare string.
+    languages: pick('languages', b.languages),
     cwd: pick('cwd', cwd),
     shell: pick('shell', shellName),
     shellKind: pick('shellKind', shellKind),
@@ -1486,12 +1553,20 @@ function createLocalEngine({
     // and always disposed when the turn ends.
     let shell = null;
     const getShell = () => shell || (shell = new ShellSession({ cwd: envFor(payload).cwd }));
-    const toolCtx = { getShell, signal };
     // The turn's working directory. It rides on every tool frame because a
     // tool row's args are the command or the path — never the directory the
     // command runs in — which left "where is it working in" unanswerable from
-    // the transcript.
-    const turnCwd = envFor(payload).cwd;
+    // the transcript. It also has to ride on `toolCtx`, which is what
+    // normalizeArgs (tools.js) actually resolves a RELATIVE readFile/writeFile/
+    // editFile/listDir/glob/grep path against — omitting `cwd` here meant that
+    // resolution fell back to the HOST PROCESS's own cwd (the Electron install
+    // dir off Linux, per baseDir()'s comment in tools.js, which fixed this for
+    // the no-path default but never for a path the model actually supplied).
+    // `desktopdir` rides the same way so resolvePath can correct a model's
+    // literal "Desktop" guess to the real one (platform.js's own alias fix).
+    const turnEnv = envFor(payload);
+    const turnCwd = turnEnv.cwd;
+    const toolCtx = { getShell, signal, cwd: turnCwd, desktopdir: turnEnv.desktopdir };
 
     try {
       // byok's settings row lives under the provider named IN THE MODEL id

package/lib/local/prompt.js

@@ -70,16 +70,86 @@ const TOOL_LINE =
   'across calls within the turn, like a real terminal. task spawns a specialist subagent ' +
   '(its own tool loop, same model) for a focused, self-contained piece of work.';
 
+/**
+ * One durable-language entry as a sentence fragment, accepting the three shapes
+ * a host can hand in without this file growing a dependency on the avatar
+ * module that produces them: a bare string, `{ code, name }`, or a folded
+ * profile facet `{ key, value }` (whose `value` is already prose —
+ * "writes durably in Swedish (sv), so reply in Swedish unless asked otherwise" —
+ * and is preferred as-is rather than re-rendered into something longer).
+ */
+function languageLine(entry) {
+  if (typeof entry === 'string') return entry.trim();
+  if (!entry || typeof entry !== 'object') return '';
+  if (typeof entry.value === 'string' && entry.value.trim()) return entry.value.trim();
+  const name = typeof entry.name === 'string' ? entry.name.trim() : '';
+  const code = typeof entry.code === 'string' ? entry.code.trim() : typeof entry.key === 'string' ? entry.key.trim() : '';
+  if (name && code) return `${name} (${code})`;
+  return name || code;
+}
+
 /**
  * Render the environment preamble. Everything is optional: a missing field is
  * simply omitted, so a headless caller can build a persona with nothing but
  * the identity block.
  */
 function environmentPreamble(env = {}) {
-  const { platform, arch, homedir, desktopdir, cwd, shell, shellKind, roots, appVersion, model } =
-    env || {};
+  const {
+    platform,
+    arch,
+    homedir,
+    desktopdir,
+    dataDir,
+    locale,
+    localeName,
+    languages,
+    cwd,
+    shell,
+    shellKind,
+    roots,
+    appVersion,
+    model,
+  } = env || {};
   const bits = [];
   if (platform) bits.push(`platform: ${platform}${arch ? ` (${arch})` : ''}`);
+  // The other half of "who and where is this machine": the platform line says
+  // what it runs, this says what language its user is in. It was the ONE
+  // environment fact a turn never carried, and the consequence was visible —
+  // the model mirrored whatever language the message arrived in and otherwise
+  // fell back to this prompt's English, so a Swedish user could not stop being
+  // greeted in English and a one-word request ("städa") arrived with no
+  // language to be read in.
+  if (locale) {
+    const base = String(locale).split('-')[0].toLowerCase();
+    const name = localeName ? ` (${localeName})` : '';
+    // The instruction is only load-bearing for a NON-English host: English is
+    // this prompt's own language, so "reply in English" would be noise that
+    // competes with whatever language the request is actually written in.
+    bits.push(
+      base === 'en'
+        ? `locale: ${locale}${name}`
+        : `locale: ${locale}${name} — the user's own machine and account run in this language, ` +
+            'so expect requests written in it and answer in the language the user writes to you ' +
+            'in. Use this to resolve an otherwise ambiguous request (a bare path, a pasted ' +
+            'error, a one-word command) — never to override a request written in another language.'
+    );
+  }
+  // Durable EVIDENCE, which is deliberately a separate line from `locale`: one
+  // is how the machine is configured, the other is what the user's own saved
+  // writing is in, and they can disagree (an English-configured machine used by
+  // someone who writes Swedish all day). The request in front of the model
+  // still outranks both, so the line says so rather than reading as an order to
+  // switch languages.
+  const langLines = (Array.isArray(languages) ? languages : [])
+    .map((entry) => languageLine(entry))
+    .filter(Boolean);
+  if (langLines.length) {
+    bits.push(
+      `recorded language evidence from the user's own saved writing: ${langLines.join('; ')} — ` +
+        'the language of the request in front of you always wins; this is evidence, not an ' +
+        'instruction to switch'
+    );
+  }
   if (homedir) bits.push(`home directory: ${homedir}`);
   // Named explicitly because `~/Desktop` is a GUESS that is wrong on two of the
   // three platforms this app ships to: OneDrive folder redirection moves it on
@@ -93,6 +163,20 @@ function environmentPreamble(env = {}) {
         'called "Desktop" there',
     );
   }
+  // Same failure mode as the desktop line, one directory over, and reported
+  // live: asked about the AEGIS data directory, DeepSeek emitted
+  // `C:\Users\Dator.aegiscode` — the home directory with the separator dropped —
+  // got an empty listing, and concluded the store did not exist. The path is
+  // given verbatim AND the wrong form is named, because a model reading a
+  // missing path cannot tell a typo from an empty directory.
+  if (dataDir) {
+    bits.push(
+      `AEGIS data directory: ${dataDir} — this is the store itself (config, sessions, ` +
+        'credentials, queue). Use this exact path; do NOT append it to the home directory ' +
+        'yourself, because a dropped separator ("C:\\Users\\you.aegiscode") names a path that ' +
+        'does not exist and looks like an empty directory rather than a mistake',
+    );
+  }
   if (cwd) bits.push(`working directory: ${cwd}`);
   if (shell) bits.push(`exec shell: ${shell}${shellKind ? ` (${shellKind})` : ''}`);
   if (model) bits.push(`model: ${model}`);

package/lib/local/tools.js

@@ -375,7 +375,10 @@ function normalizeArgs(name, args, ctx = {}) {
   for (const key of keys) {
     const value = input[key];
     if (typeof value !== 'string' || !value.trim()) continue; // absent → the executor's default
-    const res = platform.resolvePath(value, { cwd: ctx && ctx.cwd ? ctx.cwd : undefined });
+    const res = platform.resolvePath(value, {
+      cwd: ctx && ctx.cwd ? ctx.cwd : undefined,
+      desktopdir: ctx && ctx.desktopdir ? ctx.desktopdir : undefined,
+    });
     if (!res.ok) return { ok: false, args: input, error: `${name}: ${key} — ${res.error}` };
     if (res.path !== value) {
       if (out === input) out = { ...input };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aegis-desktop",
   "productName": "AEGIS Desktop",
-  "version": "0.8.23",
+  "version": "0.8.26",
   "description": "Thin Electron host for AEGIS — a local chat UI over the shared client/aegis.js transport. Ships transport + UI only; engine logic stays server-side.",
   "author": {
     "name": "AEGIS Code",

package/vendor/platform.js

@@ -438,6 +438,97 @@ function hasDisplay(options = {}) {
 // homeDir / resolvePath
 // ---------------------------------------------------------------------------
 
+/**
+ * Normalise anything a machine calls a locale into a BCP-47 `ll` / `ll-CC`
+ * code, or `''` for "no answer".
+ *
+ * Four spellings reach this function and only the first is already usable:
+ * `sv-SE`, the POSIX `sv_SE.UTF-8` (and `sv_SE.utf8`, `sv_SE`), the GNU
+ * `LANGUAGE` list (`sv:en:de` — the caller splits it), and the two settings
+ * that mean NOT a language: `C` and `POSIX`, which say "no locale configured"
+ * and must never render as a language called "c". The modifier tail
+ * (`@euro`, `@latin`) is dropped: it changes collation, not language.
+ */
+function normalizeLocale(value) {
+  if (value == null) return '';
+  const raw = String(value).trim();
+  if (!raw) return '';
+  const head = raw.split('@')[0].split('.')[0];
+  if (/^(c|posix)$/i.test(head)) return '';
+  const m = /^([A-Za-z]{2,3})(?:[_-]([A-Za-z0-9]{2,8}))?$/.exec(head);
+  if (!m) return '';
+  const lang = m[1].toLowerCase();
+  if (lang === 'c' || lang === 'posix') return '';
+  return m[2] ? `${lang}-${m[2].toUpperCase()}` : lang;
+}
+
+/**
+ * The language the user's own machine and account run in — `''` when nothing
+ * can say.
+ *
+ * The model has always been told the platform, the home directory and the real
+ * Desktop path, but never this, so a Swedish user's DeepSeek turn started with
+ * no field saying the machine is Swedish: the model mirrored whatever language
+ * arrived in the message and defaulted to the prompt's English otherwise.
+ * Mirrored language is not the same as known language — an up-front
+ * `locale: sv-SE` is what lets it answer a Swedish one-word request ("städa")
+ * in Swedish instead of asking which language to use.
+ *
+ * POSIX order is the order below (`LC_ALL` overrides `LC_CTYPE` overrides
+ * `LC_MESSAGES` overrides `LANG`); `LANGUAGE` is a GNU preference LIST and is
+ * consulted last only for its first entry. Windows sets none of these, and
+ * macOS sets none of them for an app launched from Finder, so `Intl` is the
+ * fallback — it reads the ICU default the runtime was started with, which is
+ * the same answer the OS gives the app. An `env` the caller INJECTED is trusted
+ * as given (never topped up from `Intl`), which is what makes a test with
+ * `env: {}` deterministic instead of dependent on the CI runner's locale.
+ */
+function appLocale(options = {}) {
+  const { platform, env, o } = seams(options);
+  if (typeof o.locale === 'string') return normalizeLocale(o.locale);
+  const injected = o.env && typeof o.env === 'object';
+  for (const key of ['LC_ALL', 'LC_CTYPE', 'LC_MESSAGES', 'LANG']) {
+    const hit = normalizeLocale(envValue(env, key, platform));
+    if (hit) return hit;
+  }
+  const list = String(envValue(env, 'LANGUAGE', platform) || '');
+  if (list) {
+    // A colon list is a PREFERENCE order, and an empty field in it (":de" — how
+    // a launch script that cleared the first entry leaves it) means "skip this
+    // one", not "the answer is nothing".
+    for (const part of list.split(':')) {
+      const first = normalizeLocale(part);
+      if (first) return first;
+    }
+  }
+  if (injected) return ''; // the caller owns the environment; it said nothing
+  try {
+    return normalizeLocale(new Intl.DateTimeFormat().resolvedOptions().locale);
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * The English name of a language code — `Swedish` for `sv`, `''` when the
+ * runtime has no display table for it (Node without full ICU). Named in
+ * ENGLISH on purpose: it is interpolated into the English system prompt, so a
+ * Swedish host must not render it as "svenska".
+ */
+function languageName(code, options = {}) {
+  const { o } = seams(options);
+  if (typeof o.languageName === 'string') return o.languageName;
+  const hit = normalizeLocale(code);
+  if (!hit) return '';
+  const base = hit.split('-')[0];
+  try {
+    const display = new Intl.DisplayNames(['en'], { type: 'language' });
+    return display.of(base) || '';
+  } catch {
+    return '';
+  }
+}
+
 /**
  * This user's home directory, `''` when nothing can say what it is.
  *
@@ -493,17 +584,56 @@ function hasPosixModes(options = {}) {
   return !win32;
 }
 
+/**
+ * Windows' own answer for "where is this user's Desktop", straight from the
+ * registry key Explorer itself reads and OneDrive itself rewrites when it
+ * redirects a folder. This is the one source immune to BOTH ways `~/Desktop`
+ * guesses wrong at once: it already names the OneDrive path when redirection
+ * is active, and it already names the LOCALISED folder — Swedish "Skrivbord",
+ * French "Bureau", whatever the session's physical folder is actually called
+ * — because it is Windows' own record of a real path, not an English-language
+ * guess with a `?` for an ending. Guessing per-language folder names instead
+ * would mean enumerating every language Windows ships, forever one behind;
+ * asking Windows is both simpler and exact.
+ *
+ * "Shell Folders" (not "User Shell Folders") is the one queried, because it
+ * holds the already-expanded absolute path — "User Shell Folders" is allowed
+ * to hold `%USERPROFILE%`-relative values, and this function has no reason to
+ * carry its own copy of Windows' expansion rules when the other key already
+ * did that work.
+ *
+ * Returns `''` on anything but a clean hit: `reg.exe` missing, a non-zero
+ * exit, unparsable output, or a path the filesystem does not actually have —
+ * each of those falls through to the candidate-guessing list in desktopDir()
+ * below, which is where this function's absence has always been tolerated.
+ */
+function winShellFolderDesktop(probe, dirExists) {
+  const out = probe('reg', [
+    'query',
+    'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders',
+    '/v', 'Desktop',
+  ]);
+  if (!out) return '';
+  const m = /^\s*Desktop\s+REG_(?:EXPAND_)?SZ\s+(.+)$/im.exec(out);
+  const value = m && m[1].trim();
+  return value && dirExists(value) ? value : '';
+}
+
 /**
  * This user's real Desktop directory, or `''` when none can be found.
  *
  * `~/Desktop` is a GUESS, and it is wrong on both of the hosts this function was
  * added for:
  *
- *   - Windows with OneDrive. Folder redirection moves the live Desktop to
- *     `%USERPROFILE%\OneDrive\Desktop` and commonly leaves an empty
- *     `%USERPROFILE%\Desktop` behind, so a write to the obvious path lands in a
- *     directory the user is not looking at. `%OneDrive%` (set while OneDrive
- *     runs) is consulted first for exactly this case.
+ *   - Windows with OneDrive, or a localised session. Folder redirection moves
+ *     the live Desktop to `%USERPROFILE%\OneDrive\Desktop` (or renames it
+ *     entirely, e.g. Swedish "Skrivbord"), and commonly leaves an empty
+ *     `%USERPROFILE%\Desktop` behind, so a write to the obvious English path
+ *     lands in a directory the user is not looking at — or at a name that
+ *     does not exist on their machine at all. `winShellFolderDesktop()` above
+ *     asks Windows directly and settles both cases at once; the `%OneDrive%`-
+ *     and `home`-based guesses below only run when that lookup comes back
+ *     empty (no `reg.exe`, or the path it names no longer exists).
  *   - A localised Linux desktop. XDG translates the directory ITSELF, not just
  *     its label: a Swedish session has `~/Skrivbord` and no `~/Desktop` at all.
  *     `$XDG_DESKTOP_DIR` answers it, and `~/.config/user-dirs.dirs` is where
@@ -513,15 +643,22 @@ function hasPosixModes(options = {}) {
  *
  * Seams: `dirExists` (default: a real statSync isDirectory probe), `dirNonEmpty`
  * (default: a real readdirSync length check, used only to break the win32
- * OneDrive-vs-plain tie below) and `readText` (default: a real utf8 read,
- * `null` on any failure), so all three branches are exercised on one host.
+ * OneDrive-vs-plain guess below when the registry lookup did not settle it),
+ * `probe` (default: a real `reg.exe` spawn, `null` on any failure) and
+ * `readText` (default: a real utf8 read, `null` on any failure), so every
+ * branch is exercised on one host.
  */
 function desktopDir(options = {}) {
-  const { platform, env, win32, o } = seams(options);
+  const { platform, env, win32, probe, o } = seams(options);
   const P = win32 ? path.win32 : path.posix;
   const home = homeDir(options);
   const dirExists = typeof o.dirExists === 'function' ? o.dirExists : defaultDirExists;
   const dirNonEmpty = typeof o.dirNonEmpty === 'function' ? o.dirNonEmpty : defaultDirNonEmpty;
+
+  if (win32) {
+    const fromRegistry = winShellFolderDesktop(probe, dirExists);
+    if (fromRegistry) return fromRegistry;
+  }
   const readText = typeof o.readText === 'function' ? o.readText : defaultReadText;
 
   const candidates = [];
@@ -582,6 +719,36 @@ function desktopDir(options = {}) {
   return '';
 }
 
+/**
+ * If `work` names this user's home "Desktop" folder by its generic literal
+ * name — the one a model guesses, in English, regardless of locale or
+ * OneDrive redirection — rewrite it to the REAL desktop directory the caller
+ * already asked Windows/XDG for (`desktopDir()` above).
+ *
+ * The environment preamble already NAMES the real directory and tells the
+ * model to copy it verbatim rather than build it — but that is advisory, and
+ * a model that still writes `~/Desktop/notes.txt` was silently creating (and
+ * reporting success into) a spurious English "Desktop" folder next to the
+ * user's real one, which on a redirected or localised Windows session is a
+ * different, empty directory the user never sees. This is the opposite of
+ * desktopDir()'s own job: that function stops US from guessing a locale name;
+ * this stops a model's literal "Desktop" guess from winning when we were
+ * already told the real answer.
+ *
+ * No-op when no `desktopdir` was supplied, when it is simply `home/Desktop`
+ * (nothing to correct), or when `work` is not rooted at the guessed path.
+ */
+function applyDesktopAlias(work, { home, desktopdir, win32, P }) {
+  if (!home || !desktopdir) return work;
+  const guessed = P.join(home, 'Desktop');
+  const fold = (s) => (win32 ? s.toLowerCase() : s);
+  if (fold(guessed) === fold(desktopdir)) return work;
+  if (fold(work) === fold(guessed)) return desktopdir;
+  const prefix = guessed + P.sep;
+  if (fold(work).startsWith(fold(prefix))) return desktopdir + P.sep + work.slice(prefix.length);
+  return work;
+}
+
 /** `C:\…` / `C:/…` — a drive-qualified Windows path. */
 const WIN_DRIVE_RE = /^[A-Za-z]:[\\/]/;
 /** `C:` with nothing after it — drive-relative, and never what a model means. */
@@ -657,6 +824,12 @@ function resolvePath(input, options = {}) {
     );
   }
 
+  // ── the desktop alias ─────────────────────────────────────────────────────
+  // Runs before the wrong-OS check below because a corrected `work` is always
+  // native by construction (desktopDir() returns a real path for THIS
+  // platform), exactly like a `~` expansion already is.
+  work = applyDesktopAlias(work, { home: homeDir(options), desktopdir: o.desktopdir, win32, P });
+
   // ── absolute-for-the-wrong-OS ─────────────────────────────────────────────
   // Skipped after a `~` expansion: that result is native by construction.
   if (!expandedHome) {
@@ -709,6 +882,9 @@ const api = {
   desktopDir,
   resolvePath,
   hasPosixModes,
+  appLocale,
+  languageName,
+  normalizeLocale,
 };
 
 module.exports = api;

package/vendor/session-store.js

@@ -288,6 +288,31 @@ function recordExchange(dir, exchange) {
   });
 }
 
+/**
+ * Stamp a conversation's name.
+ *
+ * The name is what the session LIST shows (the desktop app, the MCP plugin and
+ * `/resume` all read it from here or from their own mirror), and it is NOT the
+ * raw first message: `recordExchange` seeds `title` with the prompt so a
+ * session has something to show before anything has named it, and this replaces
+ * that seed with the real name once one exists (the CLI's `naming.js`).
+ *
+ * An empty name is refused rather than written: a namer that failed must not
+ * blank a name that is already there.
+ */
+function setTitle(dir, sessionId, title) {
+  const clean = String(title == null ? '' : title).trim().slice(0, 200);
+  if (!sessionId || !clean) return null;
+  return mutate(dir, (sessions) => {
+    const session = sessions[sessionId];
+    if (!session) return null;
+    session.title = clean;
+    session.updatedAt = Date.now();
+    session.seq = nextSeq(sessions);
+    return session;
+  });
+}
+
 function listSessions(dir) {
   const sessions = load(dir);
   return Object.values(sessions)
@@ -389,10 +414,15 @@ function listSummaries(dir, limit = 8) {
     .map((s) => {
       const messages = Array.isArray(s.messages) ? s.messages : [];
       const first = messages.find((m) => m && m.role === 'user');
+      // A named session lists by its name. `title` is seeded from the prompt at
+      // record time, so for an unnamed session this is the same string the
+      // first message would have produced — no visible change — while a real
+      // name (setTitle) wins over the raw prompt, which is the whole point of
+      // naming a conversation.
       return {
         id: s.id,
         cwd: (s.cwd || '').split(/[\\/]/).filter(Boolean).pop() || '~',
-        summary: String((first && first.content) || s.title || '').slice(0, 60),
+        summary: String(s.title || (first && first.content) || '').slice(0, 60),
         time: new Date(s.updatedAt || Date.now()).toISOString(),
         own: true,
         origin: s.origin || 'unknown',
@@ -499,6 +529,7 @@ module.exports = {
   upsertSession,
   appendMessage,
   recordExchange,
+  setTitle,
   listSessions,
   getSession,
   deleteSession,