mulmoclaude 0.1.2 → 0.3.0

package/src/composables/usePendingCalls.ts

@@ -59,7 +59,7 @@ export function usePendingCalls(opts: UsePendingCallsOptions) {
     // unused.
     const __tickDep = displayTick.value;
     const now = Date.now();
-    return opts.toolCallHistory.value.filter((c) => __tickDep >= 0 && isCallStillPending(c, now));
+    return opts.toolCallHistory.value.filter((entry) => __tickDep >= 0 && isCallStillPending(entry, now));
   });
 
   function teardown(): void {

package/src/composables/usePubSub.ts

@@ -21,16 +21,16 @@ let socket: Socket | null = null;
 
 const listeners = new Map<string, Set<Callback>>();
 
-function resendSubscriptions(s: Socket): void {
+function resendSubscriptions(sock: Socket): void {
   for (const channel of listeners.keys()) {
-    s.emit("subscribe", channel);
+    sock.emit("subscribe", channel);
   }
 }
 
 function connect(): Socket {
   if (socket) return socket;
 
-  const s = io({
+  const sock = io({
     path: "/ws/pubsub",
     // Match the server. Long-polling is fine as a fallback but
     // the server refuses it, so don't negotiate it here either —
@@ -38,17 +38,17 @@ function connect(): Socket {
     transports: ["websocket"],
   });
 
-  s.on("connect", () => resendSubscriptions(s));
+  sock.on("connect", () => resendSubscriptions(sock));
 
-  s.on("data", (msg: PubSubMessage) => {
+  sock.on("data", (msg: PubSubMessage) => {
     const cbs = listeners.get(msg.channel);
     if (cbs) {
-      for (const cb of cbs) cb(msg.data);
+      for (const handler of cbs) handler(msg.data);
     }
   });
 
-  socket = s;
-  return s;
+  socket = sock;
+  return sock;
 }
 
 function maybeDisconnect(): void {
@@ -63,8 +63,8 @@ export function usePubSub() {
     if (!listeners.has(channel)) listeners.set(channel, new Set());
     listeners.get(channel)!.add(callback);
 
-    const s = connect();
-    if (s.connected) s.emit("subscribe", channel);
+    const sock = connect();
+    if (sock.connected) sock.emit("subscribe", channel);
     // If not yet connected, the "connect" handler replays every
     // listener's subscription, so newly-added channels are
     // covered without extra bookkeeping.

package/src/composables/useRoles.ts

@@ -17,7 +17,7 @@ export function useRoles(): {
 } {
   const roles = ref<Role[]>(ROLES);
   const currentRoleId = ref(ROLES[0].id);
-  const currentRole = computed(() => roles.value.find((r) => r.id === currentRoleId.value) ?? roles.value[0]);
+  const currentRole = computed(() => roles.value.find((role) => role.id === currentRoleId.value) ?? roles.value[0]);
 
   async function refreshRoles(): Promise<void> {
     const result = await apiGet<Role[]>(API_ROUTES.roles.list);

package/src/composables/useSandboxStatus.ts

@@ -29,7 +29,7 @@ function isSandboxStatus(raw: RawResponse): raw is {
 } {
   if (typeof raw.sshAgent !== "boolean") return false;
   if (!Array.isArray(raw.mounts)) return false;
-  return raw.mounts.every((m) => typeof m === "string");
+  return raw.mounts.every((mount) => typeof mount === "string");
 }
 
 export interface UseSandboxStatusHandle {

package/src/composables/useSessionDerived.ts

@@ -16,7 +16,7 @@ export function useSessionDerived(opts: { sessionMap: Map<string, ActiveSession>
 
   const sidebarResults = computed(() => deduplicateResults(toolResults.value));
 
-  const currentSummary = computed(() => sessions.value.find((s) => s.id === currentSessionId.value));
+  const currentSummary = computed(() => sessions.value.find((summary) => summary.id === currentSessionId.value));
 
   // The server-side summary already merges pendingGenerations into
   // `isRunning` (see server/api/routes/sessions.ts), but pub/sub events
@@ -33,9 +33,9 @@ export function useSessionDerived(opts: { sessionMap: Map<string, ActiveSession>
 
   const toolCallHistory = computed<ToolCallHistoryItem[]>(() => activeSession.value?.toolCallHistory ?? []);
 
-  const activeSessionCount = computed(() => sessions.value.filter((s) => s.isRunning).length);
+  const activeSessionCount = computed(() => sessions.value.filter((session) => session.isRunning).length);
 
-  const unreadCount = computed(() => sessions.value.filter((s) => s.hasUnread).length);
+  const unreadCount = computed(() => sessions.value.filter((session) => session.hasUnread).length);
 
   return {
     activeSession,

package/src/composables/useSessionSync.ts

@@ -29,20 +29,20 @@ export function useSessionSync(opts: {
       console.warn("[session-sync] failed to fetch sessions:", err);
       return;
     }
-    for (const s of summaries) {
-      const live = sessionMap.get(s.id);
+    for (const summary of summaries) {
+      const live = sessionMap.get(summary.id);
       if (!live) continue;
-      live.isRunning = s.isRunning ?? false;
-      live.statusMessage = s.statusMessage ?? "";
-      const unread = s.hasUnread ?? false;
-      if (!(unread && s.id === currentSessionId.value)) {
+      live.isRunning = summary.isRunning ?? false;
+      live.statusMessage = summary.statusMessage ?? "";
+      const unread = summary.hasUnread ?? false;
+      if (!(unread && summary.id === currentSessionId.value)) {
         live.hasUnread = unread;
       }
     }
   }
 
-  async function markSessionRead(id: string): Promise<void> {
-    const result = await apiPost<{ ok: boolean }>(API_ROUTES.sessions.markRead.replace(":id", encodeURIComponent(id)));
+  async function markSessionRead(sessionId: string): Promise<void> {
+    const result = await apiPost<{ ok: boolean }>(API_ROUTES.sessions.markRead.replace(":id", encodeURIComponent(sessionId)));
     if (!result.ok || result.data.ok === false) {
       await refreshSessionStates();
     }

package/src/composables/useViewLayout.ts

@@ -9,8 +9,8 @@ import { CANVAS_VIEW, type CanvasViewMode } from "../utils/canvas/viewMode";
 const CHAT_VIEWS = [CANVAS_VIEW.single, CANVAS_VIEW.stack] as const;
 type ChatViewMode = (typeof CHAT_VIEWS)[number];
 
-function isChatView(m: string): m is ChatViewMode {
-  return (CHAT_VIEWS as readonly string[]).includes(m);
+function isChatView(mode: string): mode is ChatViewMode {
+  return (CHAT_VIEWS as readonly string[]).includes(mode);
 }
 
 export function useViewLayout(opts: {

package/src/config/roles.ts

@@ -330,6 +330,6 @@ export type BuiltInRoleId = (typeof BUILTIN_ROLE_IDS)[keyof typeof BUILTIN_ROLE_
 
 export const DEFAULT_ROLE_ID: BuiltInRoleId = BUILTIN_ROLE_IDS.general;
 
-export function getRole(id: string): Role {
-  return ROLES.find((r) => r.id === id) ?? ROLES[0];
+export function getRole(roleId: string): Role {
+  return ROLES.find((role) => role.id === roleId) ?? ROLES[0];
 }

package/src/plugins/chart/Preview.vue

@@ -25,8 +25,8 @@ const hint = computed(() => {
   const charts = data.value?.document?.charts ?? [];
   if (charts.length === 0) return "";
   const types = charts
-    .map((c) => c.type ?? inferTypeFromOption(c.option))
-    .filter((t): t is string => Boolean(t))
+    .map((chart) => chart.type ?? inferTypeFromOption(chart.option))
+    .filter((chartType): chartType is string => Boolean(chartType))
     .slice(0, 3);
   const suffix = charts.length > types.length ? ", …" : "";
   const typeList = types.join(", ");
@@ -41,8 +41,8 @@ function inferTypeFromOption(option: Record<string, unknown>): string | null {
     const first = series[0] as { type?: unknown };
     if (typeof first.type === "string") return first.type;
   } else if (series && typeof series === "object") {
-    const t = (series as { type?: unknown }).type;
-    if (typeof t === "string") return t;
+    const seriesType = (series as { type?: unknown }).type;
+    if (typeof seriesType === "string") return seriesType;
   }
   return null;
 }

package/src/plugins/manageSkills/View.vue

@@ -173,7 +173,7 @@ const saving = ref(false);
 const editDescription = ref("");
 const editBody = ref("");
 
-const selected = computed(() => skills.value.find((s) => s.name === selectedName.value) ?? null);
+const selected = computed(() => skills.value.find((skill) => skill.name === selectedName.value) ?? null);
 
 const renderedBody = computed(() => {
   const body = detail.value?.body;
@@ -272,7 +272,7 @@ async function saveEdit(): Promise<void> {
     body: editBody.value,
   };
   // Update the sidebar summary too.
-  const idx = skills.value.findIndex((s) => s.name === name);
+  const idx = skills.value.findIndex((skill) => skill.name === name);
   if (idx >= 0) {
     skills.value[idx] = {
       ...skills.value[idx],
@@ -311,7 +311,7 @@ async function deleteSkill(): Promise<void> {
     return;
   }
   // Remove from the local list, advance selection, clear detail.
-  const idx = skills.value.findIndex((s) => s.name === name);
+  const idx = skills.value.findIndex((skill) => skill.name === name);
   if (idx >= 0) {
     skills.value.splice(idx, 1);
   }

package/src/plugins/manageSource/Preview.vue

@@ -24,7 +24,7 @@ const hint = computed(() => {
   if (sources.length === 0) return "No sources registered yet.";
   const names = sources
     .slice(0, 3)
-    .map((s: Source) => s.slug)
+    .map((source: Source) => source.slug)
     .join(", ");
   const tail = sources.length > 3 ? ", …" : "";
   const plural = sources.length === 1 ? "" : "s";

package/src/plugins/markdown/View.vue

@@ -156,8 +156,8 @@ const sourceDetails = ref<HTMLDetailsElement>();
 const editing = ref(false);
 const { copied, copy } = useClipboardCopy();
 
-function onDetailsToggle(e: Event) {
-  const open = (e.target as HTMLDetailsElement).open;
+function onDetailsToggle(event: Event) {
+  const open = (event.target as HTMLDetailsElement).open;
   editing.value = open;
   if (!open) {
     editableMarkdown.value = markdownContent.value;

package/src/plugins/presentHtml/helpers.ts

@@ -25,8 +25,8 @@ export function stripHtmlToPreview(html: string, maxLength: number): string {
   };
   let i = 0;
   while (i < html.length) {
-    const c = html[i];
-    if (c === "<") {
+    const char = html[i];
+    if (char === "<") {
       const close = html.indexOf(">", i + 1);
       if (close !== -1) {
         // Real tag span `<...>` — skip it, emit a separator.
@@ -36,7 +36,7 @@ export function stripHtmlToPreview(html: string, maxLength: number): string {
       }
       // No closing `>` anywhere after — treat as literal.
     }
-    emitChar(state, c);
+    emitChar(state, char);
     i++;
   }
   trimTrailingSpace(state.out);
@@ -48,12 +48,12 @@ interface WalkerState {
   lastWasSpace: boolean;
 }
 
-function emitChar(state: WalkerState, c: string): void {
-  if (isWhitespace(c)) {
+function emitChar(state: WalkerState, char: string): void {
+  if (isWhitespace(char)) {
     emitSeparator(state);
     return;
   }
-  state.out.push(c);
+  state.out.push(char);
   state.lastWasSpace = false;
 }
 
@@ -67,6 +67,6 @@ function trimTrailingSpace(out: string[]): void {
   if (out.length > 0 && out[out.length - 1] === " ") out.pop();
 }
 
-function isWhitespace(c: string): boolean {
-  return c === " " || c === "\t" || c === "\n" || c === "\r" || c === "\v" || c === "\f";
+function isWhitespace(char: string): boolean {
+  return char === " " || char === "\t" || char === "\n" || char === "\r" || char === "\v" || char === "\f";
 }

package/src/plugins/presentMulmoScript/View.vue

@@ -431,7 +431,7 @@ const charErrors = reactive<Record<string, string>>({});
 const charDragOver = reactive<Record<string, boolean>>({});
 const beatDragOver = reactive<Record<number, boolean>>({});
 
-const anyBeatRendering = computed(() => Object.values(renderState).some((s) => s === "rendering"));
+const anyBeatRendering = computed(() => Object.values(renderState).some((state) => state === "rendering"));
 
 const characterKeys = computed(() => {
   const imgs = script.value.imageParams?.images ?? {};
@@ -447,10 +447,10 @@ const chatSessionId = computed(() => activeSessionRef?.value?.id);
 const pendingForThisScript = computed(() => {
   const out: Record<string, PendingGeneration> = {};
   const pending = activeSessionRef?.value?.pendingGenerations ?? {};
-  const fp = filePath.value;
-  if (!fp) return out;
+  const currentPath = filePath.value;
+  if (!currentPath) return out;
   for (const [mapKey, entry] of Object.entries(pending)) {
-    if (entry.filePath === fp) out[mapKey] = entry;
+    if (entry.filePath === currentPath) out[mapKey] = entry;
   }
   return out;
 });

package/src/plugins/presentMulmoScript/helpers.ts

@@ -63,7 +63,7 @@ export function shouldAutoRenderBeat(beat: { image?: { type?: string } | undefin
  * what's missing after a movie-generation event arrives.
  */
 export function getMissingCharacterKeys(keys: readonly string[], images: Record<string, unknown>, renderState: Record<string, string | undefined>): string[] {
-  return keys.filter((k) => !images[k] && renderState[k] !== "rendering");
+  return keys.filter((charKey) => !images[charKey] && renderState[charKey] !== "rendering");
 }
 
 /**

package/src/plugins/scheduler/Preview.vue

@@ -26,8 +26,8 @@ const items = ref<ScheduledItem[]>(props.result.data?.items ?? []);
 const { refresh } = useFreshPluginData<ScheduledItem[]>({
   endpoint: () => API_ROUTES.scheduler.base,
   extract: (json) => {
-    const v = (json as { data?: { items?: ScheduledItem[] } }).data?.items;
-    return Array.isArray(v) ? v : null;
+    const extracted = (json as { data?: { items?: ScheduledItem[] } }).data?.items;
+    return Array.isArray(extracted) ? extracted : null;
   },
   apply: (data) => {
     items.value = data;
@@ -49,15 +49,15 @@ const upcomingItems = computed(() => {
   const noDate: ScheduledItem[] = [];
 
   for (const item of items.value) {
-    const d = item.props.date;
-    if (typeof d === "string") {
-      if (d >= today) withDate.push(item);
+    const dateVal = item.props.date;
+    if (typeof dateVal === "string") {
+      if (dateVal >= today) withDate.push(item);
     } else {
       noDate.push(item);
     }
   }
 
-  withDate.sort((a, b) => (String(a.props.date) < String(b.props.date) ? -1 : 1));
+  withDate.sort((itemA, itemB) => (String(itemA.props.date) < String(itemB.props.date) ? -1 : 1));
 
   return [...withDate, ...noDate];
 });

package/src/plugins/scheduler/TasksTab.vue

@@ -168,9 +168,9 @@ function formatSchedule(schedule: TaskSchedule): string {
   return JSON.stringify(schedule);
 }
 
-async function runTask(id: string): Promise<void> {
+async function runTask(taskId: string): Promise<void> {
   mutationError.value = "";
-  const url = API_ROUTES.scheduler.taskRun.replace(":id", id);
+  const url = API_ROUTES.scheduler.taskRun.replace(":id", taskId);
   const result = await apiPost(url, {});
   if (!result.ok) {
     mutationError.value = `Run failed: ${result.error}`;
@@ -190,9 +190,9 @@ async function toggleEnabled(task: SchedulerTask): Promise<void> {
   await fetchTasks();
 }
 
-async function deleteTask(id: string): Promise<void> {
+async function deleteTask(taskId: string): Promise<void> {
   mutationError.value = "";
-  const url = API_ROUTES.scheduler.task.replace(":id", id);
+  const url = API_ROUTES.scheduler.task.replace(":id", taskId);
   const result = await apiDelete(url);
   if (!result.ok) {
     mutationError.value = `Delete failed: ${result.error}`;

package/src/plugins/textResponse/View.vue

@@ -168,8 +168,8 @@ const { pdfDownloading, pdfError, downloadPdf: rawDownloadPdf } = usePdfDownload
 const detailsEl = ref<HTMLDetailsElement>();
 const editing = ref(false);
 
-function onDetailsToggle(e: Event) {
-  editing.value = (e.target as HTMLDetailsElement).open;
+function onDetailsToggle(event: Event) {
+  editing.value = (event.target as HTMLDetailsElement).open;
 }
 
 onMounted(() => {

package/src/plugins/todo/Preview.vue

@@ -42,8 +42,8 @@ const items = ref<TodoItem[]>(props.result.data?.items ?? []);
 const { refresh } = useFreshPluginData<TodoItem[]>({
   endpoint: () => API_ROUTES.todos.list,
   extract: (json) => {
-    const v = (json as { data?: { items?: TodoItem[] } }).data?.items;
-    return Array.isArray(v) ? v : null;
+    const extracted = (json as { data?: { items?: TodoItem[] } }).data?.items;
+    return Array.isArray(extracted) ? extracted : null;
   },
   apply: (data) => {
     items.value = data;

package/src/plugins/todo/View.vue

@@ -111,8 +111,8 @@ const items = ref<TodoItem[]>(props.selectedResult.data?.items ?? []);
 const { refresh } = useFreshPluginData<TodoItem[]>({
   endpoint: () => API_ROUTES.todos.list,
   extract: (json) => {
-    const v = (json as { data?: { items?: TodoItem[] } }).data?.items;
-    return Array.isArray(v) ? v : null;
+    const extracted = (json as { data?: { items?: TodoItem[] } }).data?.items;
+    return Array.isArray(extracted) ? extracted : null;
   },
   apply: (data) => {
     items.value = data;
@@ -163,12 +163,12 @@ function clearFilters(): void {
 
 // ── YAML helpers ─────────────────────────────────────────────────────────────
 
-function yamlStringValue(v: string): string {
-  const needsQuotes = v === "" || /[:#[\]{},&*?|<>=!%@`]/.test(v) || /^\s|\s$/.test(v) || /^(true|false|null|~)$/i.test(v) || /^\d/.test(v);
+function yamlStringValue(str: string): string {
+  const needsQuotes = str === "" || /[:#[\]{},&*?|<>=!%@`]/.test(str) || /^\s|\s$/.test(str) || /^(true|false|null|~)$/i.test(str) || /^\d/.test(str);
   if (needsQuotes) {
-    return `"${v.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+    return `"${str.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
   }
-  return v;
+  return str;
 }
 
 function serializeYaml(item: TodoItem): string {
@@ -191,19 +191,19 @@ function parseFlowSequence(raw: string): string[] {
   let buffer = "";
   let inQuotes = false;
   for (let i = 0; i < inner.length; i++) {
-    const ch = inner[i];
-    if (ch === '"' && inner[i - 1] !== "\\") {
+    const char = inner[i];
+    if (char === '"' && inner[i - 1] !== "\\") {
       inQuotes = !inQuotes;
-      buffer += ch;
+      buffer += char;
       continue;
     }
-    if (ch === "," && !inQuotes) {
+    if (char === "," && !inQuotes) {
       const piece = parseYamlValue(buffer.trim());
       if (piece) result.push(piece);
       buffer = "";
       continue;
     }
-    buffer += ch;
+    buffer += char;
   }
   const last = parseYamlValue(buffer.trim());
   if (last) result.push(last);

package/src/plugins/todo/composables/useTodos.ts

@@ -166,12 +166,12 @@ export function useTodos(initialItems: TodoItem[] = [], initialColumns: StatusCo
     error,
     refresh,
     createItem: (input) => call(API_ROUTES.todos.items, "POST", input),
-    patchItem: (id, input) => call(API_ROUTES.todos.item.replace(":id", encodeURIComponent(id)), "PATCH", input),
-    moveItem: (id, input) => call(API_ROUTES.todos.itemMove.replace(":id", encodeURIComponent(id)), "POST", input),
-    deleteItem: (id) => call(API_ROUTES.todos.item.replace(":id", encodeURIComponent(id)), "DELETE"),
+    patchItem: (itemId, input) => call(API_ROUTES.todos.item.replace(":id", encodeURIComponent(itemId)), "PATCH", input),
+    moveItem: (itemId, input) => call(API_ROUTES.todos.itemMove.replace(":id", encodeURIComponent(itemId)), "POST", input),
+    deleteItem: (itemId) => call(API_ROUTES.todos.item.replace(":id", encodeURIComponent(itemId)), "DELETE"),
     addColumn: (input) => call(API_ROUTES.todos.columns, "POST", input),
-    patchColumn: (id, input) => call(API_ROUTES.todos.column.replace(":id", encodeURIComponent(id)), "PATCH", input),
-    deleteColumn: (id) => call(API_ROUTES.todos.column.replace(":id", encodeURIComponent(id)), "DELETE"),
+    patchColumn: (colId, input) => call(API_ROUTES.todos.column.replace(":id", encodeURIComponent(colId)), "PATCH", input),
+    deleteColumn: (colId) => call(API_ROUTES.todos.column.replace(":id", encodeURIComponent(colId)), "DELETE"),
     reorderColumns: (ids) => call(API_ROUTES.todos.columnsOrder, "PUT", { ids }),
   };
 }

package/src/plugins/wiki/Preview.vue

@@ -43,11 +43,11 @@ const { refresh } = useFreshPluginData<WikiData>({
 watch(
   () => props.result.uuid,
   () => {
-    const d = props.result.data;
-    if (d) {
-      action.value = d.action ?? "index";
-      title.value = d.title ?? "Wiki";
-      pageEntries.value = d.pageEntries ?? [];
+    const wikiData = props.result.data;
+    if (wikiData) {
+      action.value = wikiData.action ?? "index";
+      title.value = wikiData.title ?? "Wiki";
+      pageEntries.value = wikiData.pageEntries ?? [];
     }
     void refresh();
   },

package/src/plugins/wiki/helpers.ts

@@ -43,11 +43,11 @@ export function renderWikiLinks(content: string): string {
  * immediately after `from` (zero-length page name, which the old
  * regex rejected via the `+` quantifier).
  */
-function findNextCloseBrackets(s: string, from: number): number {
+function findNextCloseBrackets(str: string, from: number): number {
   let j = from;
-  while (j < s.length) {
-    if (s[j] === "]") {
-      if (s[j + 1] === "]" && j > from) return j;
+  while (j < str.length) {
+    if (str[j] === "]") {
+      if (str[j + 1] === "]" && j > from) return j;
       // Bare `]` inside the page-name span — old regex would not
       // match here, so we bail and let the caller emit the `[[`
       // as literal text.

package/src/router/guards.ts

@@ -18,43 +18,43 @@ import { VALID_VIEW_MODES } from "../utils/canvas/viewMode";
 // doesn't exist on the server" gracefully.
 const SESSION_ID_RE = /^[\w-]{1,128}$/;
 
-function isValidSessionId(id: unknown): boolean {
-  return typeof id === "string" && SESSION_ID_RE.test(id);
+function isValidSessionId(value: unknown): boolean {
+  return typeof value === "string" && SESSION_ID_RE.test(value);
 }
 
 export function installGuards(router: Router): void {
-  router.beforeEach((to) => {
+  router.beforeEach((dest) => {
     // Only run guards on the chat route — other routes (redirect, etc.)
     // don't carry parameters that need sanitizing.
-    if (to.name !== "chat") return;
+    if (dest.name !== "chat") return;
 
     // ── sessionId format check ───────────────────────────────────
-    const sessionId = to.params.sessionId;
+    const sessionId = dest.params.sessionId;
     if (typeof sessionId === "string" && sessionId.length > 0 && !isValidSessionId(sessionId)) {
       // Garbage sessionId → strip it and go to /chat (new session).
       return { name: "chat", params: {}, query: {}, replace: true };
     }
 
     // ── view mode whitelist ──────────────────────────────────────
-    const view = to.query.view;
+    const view = dest.query.view;
     if (typeof view === "string" && !VALID_VIEW_MODES.has(view)) {
-      const cleaned = { ...to.query };
+      const cleaned = { ...dest.query };
       delete cleaned.view;
-      return { ...to, query: cleaned, replace: true };
+      return { ...dest, query: cleaned, replace: true };
     }
 
     // ── file path traversal check ────────────────────────────────
-    const filePath = to.query.path;
+    const filePath = dest.query.path;
     if (typeof filePath === "string") {
       if (filePath.includes("..") || filePath.startsWith("/")) {
-        const cleaned = { ...to.query };
+        const cleaned = { ...dest.query };
         delete cleaned.path;
-        return { ...to, query: cleaned, replace: true };
+        return { ...dest, query: cleaned, replace: true };
       }
 
       // ?path= without ?view=files → auto-add view=files so FilesView mounts.
       if (view !== "files") {
-        return { ...to, query: { ...to.query, view: "files" }, replace: true };
+        return { ...dest, query: { ...dest.query, view: "files" }, replace: true };
       }
     }
   });

package/src/types/session.ts

@@ -70,10 +70,11 @@ export interface ToolResultEntry extends SessionEntry {
   result: ToolResultComplete;
 }
 
-export const isTextEntry = (e: SessionEntry): e is TextEntry =>
-  (e.source === "user" || e.source === "assistant") && e.type === EVENT_TYPES.text && typeof e.message === "string";
+export const isTextEntry = (entry: SessionEntry): entry is TextEntry =>
+  (entry.source === "user" || entry.source === "assistant") && entry.type === EVENT_TYPES.text && typeof entry.message === "string";
 
-export const isToolResultEntry = (e: SessionEntry): e is ToolResultEntry => e.source === "tool" && e.type === EVENT_TYPES.toolResult && e.result !== undefined;
+export const isToolResultEntry = (entry: SessionEntry): entry is ToolResultEntry =>
+  entry.source === "tool" && entry.type === EVENT_TYPES.toolResult && entry.result !== undefined;
 
 // In-memory session held in `sessionMap`. PR #88 introduced this so
 // multiple chats can run concurrently — `id` matches the `chatSessionId`

package/src/utils/agent/request.ts

@@ -45,11 +45,11 @@ export async function postAgentRun(body: AgentRequestBody): Promise<{ ok: true }
       };
     }
     return { ok: true };
-  } catch (e) {
-    console.error("[agent] fetch error:", e);
+  } catch (err) {
+    console.error("[agent] fetch error:", err);
     return {
       ok: false,
-      error: e instanceof Error ? e.message : "Connection error.",
+      error: err instanceof Error ? err.message : "Connection error.",
     };
   }
 }

package/src/utils/dom/scrollable.ts

@@ -11,8 +11,8 @@
 // real DOM.
 export function findScrollableChild(container: HTMLElement): HTMLElement | null {
   const children = container.querySelectorAll("*");
-  for (const el of children) {
-    const html = el as HTMLElement;
+  for (const elem of children) {
+    const html = elem as HTMLElement;
     if (html.scrollHeight > html.clientHeight) {
       const style = getComputedStyle(html);
       if (style.overflowY === "auto" || style.overflowY === "scroll" || style.overflow === "auto" || style.overflow === "scroll") {

package/src/utils/files/expandedDirs.ts

@@ -13,7 +13,7 @@ export function parseStoredExpandedDirs(raw: string | null): Set<string> {
   try {
     const parsed: unknown = JSON.parse(raw);
     if (!Array.isArray(parsed)) return new Set(DEFAULT_EXPANDED);
-    const strings = parsed.filter((v): v is string => typeof v === "string");
+    const strings = parsed.filter((val): val is string => typeof val === "string");
     return new Set(strings);
   } catch {
     return new Set(DEFAULT_EXPANDED);

package/src/utils/files/sortChildren.ts

@@ -7,14 +7,14 @@ import type { FileSortMode } from "../../composables/useFileSortMode";
 // on name so the order is deterministic).
 export function sortChildren(children: readonly TreeNode[], mode: FileSortMode): TreeNode[] {
   const copy = children.slice();
-  copy.sort((a, b) => {
-    if (a.type !== b.type) return a.type === "dir" ? -1 : 1;
+  copy.sort((nodeA, nodeB) => {
+    if (nodeA.type !== nodeB.type) return nodeA.type === "dir" ? -1 : 1;
     if (mode === "recent") {
-      const am = a.modifiedMs ?? -Infinity;
-      const bm = b.modifiedMs ?? -Infinity;
-      if (am !== bm) return bm - am;
+      const modTimeA = nodeA.modifiedMs ?? -Infinity;
+      const modTimeB = nodeB.modifiedMs ?? -Infinity;
+      if (modTimeA !== modTimeB) return modTimeB - modTimeA;
     }
-    return a.name.localeCompare(b.name);
+    return nodeA.name.localeCompare(nodeB.name);
   });
   return copy;
 }