mulmoclaude 0.1.2 → 0.4.0

package/server/api/routes/sessions.ts

@@ -1,5 +1,5 @@
 import { Router, Request, Response } from "express";
-import fs from "fs";
+import { realpathSync } from "fs";
 import { readdir, stat } from "fs/promises";
 import { readTextSafe } from "../../utils/files/safe.js";
 import path from "path";
@@ -26,14 +26,14 @@ interface SessionMeta {
   origin?: SessionOrigin;
 }
 
-async function readSessionMeta(__chatDir: string, id: string): Promise<SessionMeta | null> {
+async function readSessionMeta(__chatDir: string, sessionId: string): Promise<SessionMeta | null> {
   // Try new-style .json meta first
-  const meta = await readSessionMetaIO(id);
+  const meta = await readSessionMetaIO(sessionId);
   if (meta?.roleId && meta?.startedAt) {
     return meta as SessionMeta;
   }
   // Legacy: read first line of .jsonl
-  const jsonl = await readSessionJsonl(id);
+  const jsonl = await readSessionJsonl(sessionId);
   if (jsonl) {
     const first = jsonl.split("\n").find(Boolean);
     if (first) {
@@ -102,19 +102,19 @@ const WINDOW_MS = env.sessionsListWindowDays * ONE_DAY_MS;
 export async function loadAllSessions(): Promise<{ summary: SessionSummary; changeMs: number }[]> {
   const chatDir = WORKSPACE_PATHS.chat;
   const manifest = await readManifest(workspacePath);
-  const indexById = new Map<string, ChatIndexEntry>(manifest.entries.map((e) => [e.id, e]));
+  const indexById = new Map<string, ChatIndexEntry>(manifest.entries.map((entry) => [entry.id, entry]));
   const cutoff = WINDOW_MS > 0 ? Date.now() - WINDOW_MS : 0;
 
-  const files = (await readdir(chatDir)).filter((f) => f.endsWith(".jsonl"));
+  const files = (await readdir(chatDir)).filter((fileName) => fileName.endsWith(".jsonl"));
   const rows = await Promise.all(
     files.map(async (file) => {
-      const id = file.replace(".jsonl", "");
+      const sessionId = file.replace(".jsonl", "");
       try {
         // stat only — no readFile on .jsonl content
-        const fileStat = await stat(sessionJsonlAbsPath(id));
+        const fileStat = await stat(sessionJsonlAbsPath(sessionId));
         if (cutoff > 0 && fileStat.mtimeMs < cutoff) return null;
 
-        const meta = await readSessionMeta(chatDir, id);
+        const meta = await readSessionMeta(chatDir, sessionId);
         if (!meta) return null;
 
         // The meta sidecar bumps its mtime on hasUnread / origin
@@ -122,20 +122,20 @@ export async function loadAllSessions(): Promise<{ summary: SessionSummary; chan
         // pick up drains of background generations (which only touch
         // meta, not the jsonl). Missing stat (brand-new session
         // before its first meta write) contributes 0.
-        const metaMtimeMs = await stat(sessionMetaAbsPath(id))
-          .then((s) => s.mtimeMs)
+        const metaMtimeMs = await stat(sessionMetaAbsPath(sessionId))
+          .then((stats) => stats.mtimeMs)
           .catch(() => 0);
 
-        const indexEntry = indexById.get(id);
+        const indexEntry = indexById.get(sessionId);
         // Prefer AI title → meta.firstUserMessage → empty.
         // `summary` and `keywords` are spread conditionally
         // to respect the server tsconfig's
         // exactOptionalPropertyTypes.
         const preview = indexEntry?.title ?? meta.firstUserMessage ?? "";
 
-        const live = getSession(id);
+        const live = getSession(sessionId);
         const summary: SessionSummary = {
-          id,
+          id: sessionId,
           roleId: meta.roleId,
           startedAt: meta.startedAt,
           updatedAt: new Date(fileStat.mtimeMs).toISOString(),
@@ -161,7 +161,7 @@ export async function loadAllSessions(): Promise<{ summary: SessionSummary; chan
       }
     }),
   );
-  return rows.filter((r): r is { summary: SessionSummary; changeMs: number } => r !== null);
+  return rows.filter((row): row is { summary: SessionSummary; changeMs: number } => row !== null);
 }
 
 router.get(API_ROUTES.sessions.list, async (req: Request<object, SessionsResponse, object, SessionsQuery>, res: Response<SessionsResponse>) => {
@@ -173,15 +173,15 @@ router.get(API_ROUTES.sessions.list, async (req: Request<object, SessionsRespons
     // of whether it's in the diff. Echoing the same cursor back on an
     // empty diff (nothing changed since `?since=`) is fine; the
     // client no-ops.
-    const maxChangeMs = rows.reduce((acc, r) => Math.max(acc, r.changeMs), 0);
+    const maxChangeMs = rows.reduce((acc, row) => Math.max(acc, row.changeMs), 0);
 
-    const filtered = sinceMs > 0 ? rows.filter((r) => r.changeMs > sinceMs) : rows;
+    const filtered = sinceMs > 0 ? rows.filter((row) => row.changeMs > sinceMs) : rows;
 
-    const sessions = filtered.map((r) => r.summary);
-    sessions.sort((a, b) => {
-      const byUpdated = new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime();
+    const sessions = filtered.map((row) => row.summary);
+    sessions.sort((leftSession, rightSession) => {
+      const byUpdated = new Date(rightSession.updatedAt).getTime() - new Date(leftSession.updatedAt).getTime();
       if (byUpdated !== 0) return byUpdated;
-      return new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime();
+      return new Date(rightSession.startedAt).getTime() - new Date(leftSession.startedAt).getTime();
     });
 
     res.json({
@@ -207,13 +207,13 @@ interface SessionErrorResponse {
 }
 
 router.get(API_ROUTES.sessions.detail, async (req: Request<SessionIdParams>, res: Response<unknown[] | SessionErrorResponse>) => {
-  const { id } = req.params;
+  const { id: sessionId } = req.params;
   const chatDir = WORKSPACE_PATHS.chat;
   try {
-    const meta = await readSessionMeta(chatDir, id);
-    const content = await readSessionJsonl(id);
+    const meta = await readSessionMeta(chatDir, sessionId);
+    const content = await readSessionJsonl(sessionId);
     if (!content) {
-      notFound(res, `Session ${id} not found`);
+      notFound(res, `Session ${sessionId} not found`);
       return;
     }
     const entries = (
@@ -242,7 +242,7 @@ router.get(API_ROUTES.sessions.detail, async (req: Request<SessionIdParams>, res
                   const storiesDir = path.resolve(WORKSPACE_PATHS.stories);
                   let storiesReal: string;
                   try {
-                    storiesReal = fs.realpathSync(storiesDir);
+                    storiesReal = realpathSync(storiesDir);
                   } catch {
                     return entry;
                   }

package/server/api/routes/sessionsCursor.ts

@@ -21,8 +21,8 @@ const CURSOR_PREFIX = "v1:";
  * fall back to when an incoming cursor is malformed.
  */
 export function encodeCursor(changeMs: number): string {
-  const ms = Number.isFinite(changeMs) && changeMs > 0 ? Math.floor(changeMs) : 0;
-  return `${CURSOR_PREFIX}${ms}`;
+  const floored = Number.isFinite(changeMs) && changeMs > 0 ? Math.floor(changeMs) : 0;
+  return `${CURSOR_PREFIX}${floored}`;
 }
 
 /**
@@ -36,8 +36,8 @@ export function encodeCursor(changeMs: number): string {
 export function parseCursor(raw: unknown): number {
   if (typeof raw !== "string") return 0;
   if (!raw.startsWith(CURSOR_PREFIX)) return 0;
-  const n = Number(raw.slice(CURSOR_PREFIX.length));
-  return Number.isFinite(n) && n > 0 ? n : 0;
+  const parsed = Number(raw.slice(CURSOR_PREFIX.length));
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
 }
 
 /**

package/server/api/routes/skills.ts

@@ -55,17 +55,17 @@ interface DeleteSkillResponse {
 router.get(API_ROUTES.skills.list, async (_req: Request, res: Response<SkillsListResponse>) => {
   const skills = await discoverSkills({ workspaceRoot: workspacePath });
   res.json({
-    skills: skills.map((s) => ({
-      name: s.name,
-      description: s.description,
-      source: s.source,
+    skills: skills.map((skill) => ({
+      name: skill.name,
+      description: skill.description,
+      source: skill.source,
     })),
   });
 });
 
 router.get(API_ROUTES.skills.detail, async (req: Request<{ name: string }>, res: Response<SkillDetailResponse | ErrorResponse>) => {
   const skills = await discoverSkills({ workspaceRoot: workspacePath });
-  const skill = skills.find((s) => s.name === req.params.name);
+  const skill = skills.find((candidate) => candidate.name === req.params.name);
   if (!skill) {
     notFound(res, `skill not found: ${req.params.name}`);
     return;

package/server/api/routes/sources.ts

@@ -312,7 +312,7 @@ async function handleRegister(body: ManageSourceBody, res: Response<ManageSource
 async function handleRemove(body: ManageSourceBody, res: Response<ManageSourceSuccess | ErrorResponse>): Promise<void> {
   const slug = typeof body.slug === "string" ? body.slug.trim() : "";
   if (!isValidSlug(slug)) {
-    res.status(400).json({ error: "slug is required and must be a valid slug" });
+    badRequest(res, "slug is required and must be a valid slug");
     return;
   }
   const removed = await deleteSource(workspacePath, slug);
@@ -525,8 +525,8 @@ async function resolveCategories(parsed: ParsedRegisterBody): Promise<{ categori
 
 function isHttpUrl(raw: string): boolean {
   try {
-    const u = new URL(raw);
-    return u.protocol === "http:" || u.protocol === "https:";
+    const url = new URL(raw);
+    return url.protocol === "http:" || url.protocol === "https:";
   } catch {
     return false;
   }

package/server/api/routes/todosColumnsHandlers.ts

@@ -79,8 +79,8 @@ function uniqueId(base: string, existingIds: ReadonlySet<string>): string {
 
 // ── Validation helpers ────────────────────────────────────────────
 
-function findColumn(columns: StatusColumn[], id: string): StatusColumn | undefined {
-  return columns.find((column) => column.id === id);
+function findColumn(columns: StatusColumn[], columnId: string): StatusColumn | undefined {
+  return columns.find((column) => column.id === columnId);
 }
 
 function ensureColumnsValid(columns: StatusColumn[]): StatusColumn[] {
@@ -161,11 +161,11 @@ export function defaultStatusId(columns: StatusColumn[]): string {
 // to sync at that point.
 export function resyncDoneMembership(items: TodoItem[], newDoneId: string): { items: TodoItem[]; changed: boolean } {
   let changed = false;
-  const next = items.map((it): TodoItem => {
-    const shouldBeDone = it.status === newDoneId;
-    if (it.completed === shouldBeDone) return it;
+  const next = items.map((item): TodoItem => {
+    const shouldBeDone = item.status === newDoneId;
+    if (item.completed === shouldBeDone) return item;
     changed = true;
-    return { ...it, completed: shouldBeDone };
+    return { ...item, completed: shouldBeDone };
   });
   return { items: next, changed };
 }
@@ -178,7 +178,7 @@ export function resyncDoneMembership(items: TodoItem[], newDoneId: string): { it
 function rebuildColumnOrder(items: TodoItem[], columnId: string): TodoItem[] {
   const inColumn = items.filter((item) => item.status === columnId).sort((left, right) => (left.order ?? 0) - (right.order ?? 0));
   const newOrders = new Map<string, number>();
-  inColumn.forEach((item, i) => newOrders.set(item.id, (i + 1) * ORDER_STEP));
+  inColumn.forEach((item, index) => newOrders.set(item.id, (index + 1) * ORDER_STEP));
   return items.map((item): TodoItem => {
     const newOrder = newOrders.get(item.id);
     if (newOrder === undefined) return item;
@@ -200,23 +200,23 @@ export function handleAddColumn(columns: StatusColumn[], items: TodoItem[], inpu
     return { kind: "error", status: 400, error: "label required" };
   }
   const baseId = slugify(input.label);
-  const id = uniqueId(baseId, new Set(columns.map((column) => column.id)));
-  const col: StatusColumn = { id, label: input.label.trim() };
-  if (input.isDone === true) col.isDone = true;
+  const columnId = uniqueId(baseId, new Set(columns.map((column) => column.id)));
+  const columnToAdd: StatusColumn = { id: columnId, label: input.label.trim() };
+  if (input.isDone === true) columnToAdd.isDone = true;
   // If the new column is flagged done, demote any existing done
   // columns (only one is allowed at a time) and resync items so the
   // old done column's items are no longer marked completed. The new
   // column itself is empty so there's nothing on its side to sync.
   if (input.isDone === true) {
-    const nextColumns = [...columns.map((column) => ({ ...column, isDone: false })), col];
-    const { items: nextItems, changed } = resyncDoneMembership(items, id);
+    const nextColumns = [...columns.map((column) => ({ ...column, isDone: false })), columnToAdd];
+    const { items: nextItems, changed } = resyncDoneMembership(items, columnId);
     return {
       kind: "success",
       columns: nextColumns,
       ...(changed ? { items: nextItems } : {}),
     };
   }
-  return { kind: "success", columns: [...columns, col] };
+  return { kind: "success", columns: [...columns, columnToAdd] };
 }
 
 export interface PatchColumnInput {
@@ -224,28 +224,28 @@ export interface PatchColumnInput {
   isDone?: boolean;
 }
 
-export function handlePatchColumn(columns: StatusColumn[], id: string, input: PatchColumnInput, items: TodoItem[]): ColumnsActionResult {
-  const target = findColumn(columns, id);
+export function handlePatchColumn(columns: StatusColumn[], columnId: string, input: PatchColumnInput, items: TodoItem[]): ColumnsActionResult {
+  const target = findColumn(columns, columnId);
   if (!target) {
-    return { kind: "error", status: 404, error: `column not found: ${id}` };
+    return { kind: "error", status: 404, error: `column not found: ${columnId}` };
   }
   const patched: StatusColumn = { id: target.id, label: target.label };
   if (target.isDone) patched.isDone = true;
   if (typeof input.label === "string" && input.label.trim().length > 0) {
     patched.label = input.label.trim();
   }
-  let nextColumns = columns.map((column) => (column.id === id ? patched : column));
+  let nextColumns = columns.map((column) => (column.id === columnId ? patched : column));
   // Toggling done flag is non-trivial: only one column may be done.
   let itemsChanged = false;
   let nextItems = items;
   if (input.isDone === true && !target.isDone) {
     // Promote this column to done; demote everyone else.
-    nextColumns = nextColumns.map((column) => (column.id === id ? { ...column, isDone: true } : { id: column.id, label: column.label }));
+    nextColumns = nextColumns.map((column) => (column.id === columnId ? { ...column, isDone: true } : { id: column.id, label: column.label }));
     // Resync `completed` across all items: the new done column's
     // items become true, the old done column's items become false.
     // Doing this with the helper rather than a one-sided pass means
     // both ends of the swap stay consistent.
-    const synced = resyncDoneMembership(items, id);
+    const synced = resyncDoneMembership(items, columnId);
     nextItems = synced.items;
     itemsChanged = synced.changed;
   } else if (input.isDone === false && target.isDone) {
@@ -263,7 +263,7 @@ export function handlePatchColumn(columns: StatusColumn[], id: string, input: Pa
   };
 }
 
-export function handleDeleteColumn(columns: StatusColumn[], id: string, items: TodoItem[]): ColumnsActionResult {
+export function handleDeleteColumn(columns: StatusColumn[], columnId: string, items: TodoItem[]): ColumnsActionResult {
   if (columns.length <= 1) {
     return {
       kind: "error",
@@ -271,11 +271,11 @@ export function handleDeleteColumn(columns: StatusColumn[], id: string, items: T
       error: "cannot delete the last remaining column",
     };
   }
-  const target = findColumn(columns, id);
+  const target = findColumn(columns, columnId);
   if (!target) {
-    return { kind: "error", status: 404, error: `column not found: ${id}` };
+    return { kind: "error", status: 404, error: `column not found: ${columnId}` };
   }
-  const remaining = columns.filter((column) => column.id !== id);
+  const remaining = columns.filter((column) => column.id !== columnId);
   // If we just removed the done column, promote the new last column.
   let nextColumns = remaining;
   if (target.isDone) {
@@ -286,10 +286,10 @@ export function handleDeleteColumn(columns: StatusColumn[], id: string, items: T
   // deleted column was done; otherwise to the new default open column.
   const refugeId = target.isDone ? newDoneId : defaultStatusId(nextColumns);
   let itemsChanged = false;
-  let nextItems = items.map((it): TodoItem => {
-    if (it.status !== id) return it;
+  let nextItems = items.map((item): TodoItem => {
+    if (item.status !== columnId) return item;
     itemsChanged = true;
-    return { ...it, status: refugeId };
+    return { ...item, status: refugeId };
   });
   if (itemsChanged) {
     // The refuge column might have already had items in it; the ones
@@ -331,17 +331,17 @@ export function handleReorderColumns(columns: StatusColumn[], ids: string[]): Co
   }
   const known = new Set(columns.map((column) => column.id));
   const seen = new Set<string>();
-  for (const id of ids) {
-    if (!known.has(id) || seen.has(id)) {
+  for (const columnId of ids) {
+    if (!known.has(columnId) || seen.has(columnId)) {
       return {
         kind: "error",
         status: 400,
         error: "ids must contain every existing column id exactly once",
       };
     }
-    seen.add(id);
+    seen.add(columnId);
   }
   const byId = new Map(columns.map((column) => [column.id, column]));
-  const next = ids.map((id) => byId.get(id)!);
+  const next = ids.map((columnId) => byId.get(columnId)!);
   return { kind: "success", columns: next };
 }

package/server/api/routes/todosHandlers.ts

@@ -242,7 +242,7 @@ export function handleRemoveLabel(items: TodoItem[], input: TodosActionInput): T
 
 export function handleListLabels(items: TodoItem[]): TodosActionResult {
   const inventory = listLabelsWithCount(items);
-  const summary = inventory.map((l) => `${l.label} (${l.count})`).join(", ");
+  const summary = inventory.map((entry) => `${entry.label} (${entry.count})`).join(", ");
   const message = inventory.length === 0 ? "No labels in use" : `${inventory.length} label(s) in use: ${summary}`;
   return {
     kind: "success",

package/server/api/routes/todosItemsHandlers.ts

@@ -281,10 +281,10 @@ function applyCompletedPatch(updated: TodoItem, items: TodoItem[], columns: Stat
   }
 }
 
-export function handlePatch(items: TodoItem[], columns: StatusColumn[], id: string, input: PatchInput): ItemsActionResult {
-  const target = items.find((i) => i.id === id);
+export function handlePatch(items: TodoItem[], columns: StatusColumn[], itemId: string, input: PatchInput): ItemsActionResult {
+  const target = items.find((item) => item.id === itemId);
   if (!target) {
-    return { kind: "error", status: 404, error: `item not found: ${id}` };
+    return { kind: "error", status: 404, error: `item not found: ${itemId}` };
   }
   const updated: TodoItem = { ...target };
 
@@ -305,7 +305,7 @@ export function handlePatch(items: TodoItem[], columns: StatusColumn[], id: stri
     if (err) return err;
   }
 
-  const next = items.map((item) => (item.id === id ? updated : item));
+  const next = items.map((item) => (item.id === itemId ? updated : item));
   return { kind: "success", items: next, item: updated };
 }
 
@@ -323,10 +323,10 @@ export interface MoveInput {
   position?: number;
 }
 
-export function handleMove(items: TodoItem[], columns: StatusColumn[], id: string, input: MoveInput): ItemsActionResult {
-  const target = items.find((i) => i.id === id);
+export function handleMove(items: TodoItem[], columns: StatusColumn[], itemId: string, input: MoveInput): ItemsActionResult {
+  const target = items.find((item) => item.id === itemId);
   if (!target) {
-    return { kind: "error", status: 404, error: `item not found: ${id}` };
+    return { kind: "error", status: 404, error: `item not found: ${itemId}` };
   }
   const validStatusIds = new Set(columns.map((column) => column.id));
   const newStatus = input.status ?? target.status ?? defaultStatusId(columns);
@@ -345,7 +345,7 @@ export function handleMove(items: TodoItem[], columns: StatusColumn[], id: strin
   };
   // Re-collect the items in the target column with the moving item
   // pulled out, then splice item back in at `position`.
-  const others = items.filter((item) => item.id !== id && item.status === newStatus).sort((left, right) => (left.order ?? 0) - (right.order ?? 0));
+  const others = items.filter((item) => item.id !== itemId && item.status === newStatus).sort((left, right) => (left.order ?? 0) - (right.order ?? 0));
   const insertAt = clampPosition(input.position, others.length);
   const reordered = [...others];
   reordered.splice(insertAt, 0, updatedSelf);
@@ -354,7 +354,7 @@ export function handleMove(items: TodoItem[], columns: StatusColumn[], id: strin
   reordered.forEach((item, i) => reorderedById.set(item.id, (i + 1) * ORDER_STEP));
   const nextItems = items.map((item): TodoItem => {
     const newOrder = reorderedById.get(item.id);
-    if (item.id === id) {
+    if (item.id === itemId) {
       const out: TodoItem = {
         ...updatedSelf,
         order: newOrder ?? updatedSelf.order ?? ORDER_STEP,
@@ -364,7 +364,7 @@ export function handleMove(items: TodoItem[], columns: StatusColumn[], id: strin
     if (newOrder !== undefined) return { ...item, order: newOrder };
     return item;
   });
-  const finalSelf = nextItems.find((item) => item.id === id)!;
+  const finalSelf = nextItems.find((item) => item.id === itemId)!;
   return { kind: "success", items: nextItems, item: finalSelf };
 }
 
@@ -377,10 +377,10 @@ function clampPosition(raw: number | undefined, max: number): number {
 
 // ── Delete ────────────────────────────────────────────────────────
 
-export function handleDeleteItem(items: TodoItem[], id: string): ItemsActionResult {
-  const target = items.find((i) => i.id === id);
+export function handleDeleteItem(items: TodoItem[], itemId: string): ItemsActionResult {
+  const target = items.find((item) => item.id === itemId);
   if (!target) {
-    return { kind: "error", status: 404, error: `item not found: ${id}` };
+    return { kind: "error", status: 404, error: `item not found: ${itemId}` };
   }
-  return { kind: "success", items: items.filter((item) => item.id !== id) };
+  return { kind: "success", items: items.filter((item) => item.id !== itemId) };
 }

package/server/api/routes/wiki.ts

@@ -4,6 +4,7 @@ import { WORKSPACE_PATHS } from "../../workspace/paths.js";
 import { readTextSafeSync, readTextSafe } from "../../utils/files/safe.js";
 import { getPageIndex } from "./wiki/pageIndex.js";
 import { badRequest } from "../../utils/httpError.js";
+import { getOptionalStringQuery } from "../../utils/request.js";
 import { API_ROUTES } from "../../../src/config/apiRoutes.js";
 
 const router = Router();
@@ -46,7 +47,7 @@ function parseTableRow(trimmed: string): WikiPageEntry | null {
   const cols = trimmed
     .split("|")
     .slice(1, -1)
-    .map((c) => c.trim().replace(/^`|`$/g, ""));
+    .map((column) => column.trim().replace(/^`|`$/g, ""));
   if (cols.length < 2) return null;
   const slug = cols[0];
   const title = cols[1] || slug;
@@ -70,11 +71,11 @@ export function extractSlugFromBulletHref(rawHref: string): string {
 }
 
 function parseBulletLinkRow(trimmed: string): WikiPageEntry | null {
-  const m = BULLET_LINK_PATTERN.exec(trimmed);
-  if (!m) return null;
-  const title = m[1].trim();
-  const href = m[2] ?? "";
-  const desc = m[3]?.trim() ?? "";
+  const match = BULLET_LINK_PATTERN.exec(trimmed);
+  if (!match) return null;
+  const title = match[1].trim();
+  const href = match[2] ?? "";
+  const desc = match[3]?.trim() ?? "";
   // Prefer the slug embedded in the href so non-ASCII titles keep
   // a navigable slug. Fall back to slugifying the title only when
   // the href has no recognisable slug (rare — usually means the
@@ -84,10 +85,10 @@ function parseBulletLinkRow(trimmed: string): WikiPageEntry | null {
 }
 
 function parseBulletWikiLinkRow(trimmed: string): WikiPageEntry | null {
-  const m = BULLET_WIKI_LINK_PATTERN.exec(trimmed);
-  if (!m) return null;
-  const title = m[1].trim();
-  const desc = m[2]?.trim() ?? "";
+  const match = BULLET_WIKI_LINK_PATTERN.exec(trimmed);
+  if (!match) return null;
+  const title = match[1].trim();
+  const desc = match[2]?.trim() ?? "";
   return { title, slug: wikiSlugify(title), description: desc };
 }
 
@@ -132,21 +133,34 @@ async function resolvePagePath(pageName: string): Promise<string | null> {
 
   const slug = wikiSlugify(pageName);
 
-  const exact = slugs.get(slug);
-  if (exact) return path.join(dir, exact);
+  if (slug.length > 0) {
+    const exact = slugs.get(slug);
+    if (exact) return path.join(dir, exact);
 
-  // Fuzzy: same `includes` semantics as the old sync path — iterate
-  // the index's keys, no filesystem access.
-  for (const [key, file] of slugs) {
-    if (slug.includes(key) || key.includes(slug)) {
-      return path.join(dir, file);
+    // Fuzzy: same `includes` semantics as the old sync path — iterate
+    // the index's keys, no filesystem access.
+    for (const [key, file] of slugs) {
+      if (slug.includes(key) || key.includes(slug)) {
+        return path.join(dir, file);
+      }
     }
   }
+
+  // Non-ASCII page names (e.g. Japanese [[wiki links]]) produce empty
+  // slugs after slugification. Fall back to matching by title in the
+  // wiki index so the link resolves to its page file.
+  const indexContent = readFileOrEmpty(indexFile());
+  const entries = parseIndexEntries(indexContent);
+  const titleMatch = entries.find((entry) => entry.title === pageName);
+  if (titleMatch && slugs.has(titleMatch.slug)) {
+    return path.join(dir, slugs.get(titleMatch.slug)!);
+  }
+
   return null;
 }
 
 router.get(API_ROUTES.wiki.base, async (req: Request, res: Response<WikiResponse | ErrorResponse>) => {
-  const slug = typeof req.query.slug === "string" ? req.query.slug : undefined;
+  const slug = getOptionalStringQuery(req, "slug");
   if (slug) {
     const filePath = await resolvePagePath(slug);
     const content = filePath ? readFileOrEmpty(filePath) : "";
@@ -276,7 +290,7 @@ export function findMissingFiles(pageEntries: readonly WikiPageEntry[], fileSlug
 
 export function findBrokenLinksInPage(fileName: string, content: string, fileSlugs: ReadonlySet<string>): string[] {
   const issues: string[] = [];
-  const wikiLinks = [...content.matchAll(WIKI_LINK_PATTERN)].map((m) => m[1]);
+  const wikiLinks = [...content.matchAll(WIKI_LINK_PATTERN)].map((match) => match[1]);
   for (const link of wikiLinks) {
     const linkSlug = wikiSlugify(link);
     if (!fileSlugs.has(linkSlug)) {
@@ -302,7 +316,7 @@ async function collectLintIssues(): Promise<string[]> {
   }
   const indexContent = readFileOrEmpty(indexFile());
   const pageEntries = parseIndexEntries(indexContent);
-  const indexedSlugs = new Set(pageEntries.map((e) => e.slug));
+  const indexedSlugs = new Set(pageEntries.map((entry) => entry.slug));
   const pageFiles = [...slugs.values()];
   const fileSlugs = new Set(slugs.keys());
 
@@ -312,8 +326,8 @@ async function collectLintIssues(): Promise<string[]> {
   // Parallel read: N small markdown files, ~50 KB each. Bounded by
   // the number of wiki pages, not by CPU.
   const contents = await Promise.all(
-    pageFiles.map(async (f) => {
-      const content = await readTextSafe(path.join(dir, f));
+    pageFiles.map(async (fileName) => {
+      const content = await readTextSafe(path.join(dir, fileName));
       return content ?? "";
     }),
   );

package/server/api/sandboxStatus.ts

@@ -59,6 +59,6 @@ export function buildSandboxStatus(params: BuildSandboxStatusParams): SandboxSta
 
   return {
     sshAgent,
-    mounts: parsed.resolved.map((m) => m.name),
+    mounts: parsed.resolved.map((mount) => mount.name),
   };
 }

package/server/events/notifications.ts

@@ -32,8 +32,8 @@ export interface NotificationDeps {
 
 let deps: NotificationDeps | null = null;
 
-export function initNotifications(d: NotificationDeps): void {
-  deps = d;
+export function initNotifications(injected: NotificationDeps): void {
+  deps = injected;
 }
 
 // ── In-memory store ─────────────────────────────────────────────
@@ -97,10 +97,10 @@ export function publishNotification(opts: PublishNotificationOpts): void {
   }
 }
 
-function formatBridgeMessage(p: NotificationPayload): string {
-  const icon = p.kind === NOTIFICATION_KINDS.agent ? "\u2705" : "\u{1F514}";
-  const parts = [icon, p.title];
-  if (p.body) parts.push(p.body);
+function formatBridgeMessage(payload: NotificationPayload): string {
+  const icon = payload.kind === NOTIFICATION_KINDS.agent ? "\u2705" : "\u{1F514}";
+  const parts = [icon, payload.title];
+  if (payload.body) parts.push(payload.body);
   return parts.join(" ");
 }
 

package/server/events/pub-sub/index.ts

@@ -13,7 +13,7 @@ export interface IPubSub {
 // itself, which is why we switched off raw ws.
 
 export function createPubSub(server: http.Server): IPubSub {
-  const io = new IOServer(server, {
+  const ioServer = new IOServer(server, {
     path: "/ws/pubsub",
     // Server binds to 127.0.0.1 only, so CORS is moot — but
     // socket.io defaults to rejecting cross-origin upgrade
@@ -28,7 +28,7 @@ export function createPubSub(server: http.Server): IPubSub {
     transports: ["websocket"],
   });
 
-  io.on("connection", (socket) => {
+  ioServer.on("connection", (socket) => {
     socket.on("subscribe", (channel: unknown) => {
       if (typeof channel === "string") socket.join(channel);
     });
@@ -39,7 +39,7 @@ export function createPubSub(server: http.Server): IPubSub {
 
   return {
     publish(channel: string, data: unknown): void {
-      io.to(channel).emit("data", { channel, data });
+      ioServer.to(channel).emit("data", { channel, data });
     },
   };
 }