mulmoclaude 0.1.2 → 0.4.0

package/server/workspace/chat-index/indexer.ts

@@ -52,8 +52,8 @@ export async function readManifest(workspaceRoot: string): Promise<ChatIndexMani
 
 function isManifest(raw: unknown): raw is ChatIndexManifest {
   if (!isRecord(raw)) return false;
-  const o = raw as Record<string, unknown>;
-  return o.version === 1 && Array.isArray(o.entries);
+  const manifestRecord = raw as Record<string, unknown>;
+  return manifestRecord.version === 1 && Array.isArray(manifestRecord.entries);
 }
 
 // In-process mutex serializing the read-modify-write sequence on
@@ -64,7 +64,7 @@ function isManifest(raw: unknown): raw is ChatIndexManifest {
 // this module's single-process assumption.
 let manifestMutex: Promise<void> = Promise.resolve();
 
-async function withManifestLock<T>(fn: () => Promise<T>): Promise<T> {
+async function withManifestLock<T>(lockedFn: () => Promise<T>): Promise<T> {
   const prev = manifestMutex;
   let release: () => void = () => {};
   manifestMutex = new Promise<void>((resolve) => {
@@ -72,7 +72,7 @@ async function withManifestLock<T>(fn: () => Promise<T>): Promise<T> {
   });
   try {
     await prev;
-    return await fn();
+    return await lockedFn();
   } finally {
     release();
   }
@@ -83,12 +83,12 @@ async function withManifestLock<T>(fn: () => Promise<T>): Promise<T> {
 // already serializes callers within this process, but a unique
 // name means the rename can't collide even if a stray .tmp file
 // is left behind by a previous crashed run.
-async function writeManifestAtomic(workspaceRoot: string, m: ChatIndexManifest): Promise<void> {
+async function writeManifestAtomic(workspaceRoot: string, manifest: ChatIndexManifest): Promise<void> {
   // `uniqueTmp` belt-and-suspenders: the in-process mutex above
   // already serializes callers, but a unique tmp name means the
   // rename can't collide even if a stray .tmp file is left behind
   // by a previous crashed run.
-  await writeJsonAtomic(manifestPathFor(workspaceRoot), m, {
+  await writeJsonAtomic(manifestPathFor(workspaceRoot), manifest, {
     uniqueTmp: true,
   });
 }
@@ -117,9 +117,9 @@ export async function isFresh(workspaceRoot: string, sessionId: string, now: num
     if (!isRecord(entry)) return false;
     const indexedAt = (entry as Record<string, unknown>).indexedAt;
     if (typeof indexedAt !== "string") return false;
-    const ts = Date.parse(indexedAt);
-    if (Number.isNaN(ts)) return false;
-    return now - ts < minIntervalMs;
+    const indexedTimestamp = Date.parse(indexedAt);
+    if (Number.isNaN(indexedTimestamp)) return false;
+    return now - indexedTimestamp < minIntervalMs;
   } catch {
     return false;
   }
@@ -137,10 +137,10 @@ async function readSessionMeta(workspaceRoot: string, sessionId: string): Promis
     const raw = await readFile(sessionMetaPathFor(workspaceRoot, sessionId), "utf-8");
     const parsed: unknown = JSON.parse(raw);
     if (!isRecord(parsed)) return {};
-    const o = parsed as Record<string, unknown>;
+    const metaRecord = parsed as Record<string, unknown>;
     return {
-      roleId: typeof o.roleId === "string" ? o.roleId : undefined,
-      startedAt: typeof o.startedAt === "string" ? o.startedAt : undefined,
+      roleId: typeof metaRecord.roleId === "string" ? metaRecord.roleId : undefined,
+      startedAt: typeof metaRecord.startedAt === "string" ? metaRecord.startedAt : undefined,
     };
   } catch {
     return {};
@@ -152,7 +152,7 @@ async function readSessionMeta(workspaceRoot: string, sessionId: string): Promis
 export async function listSessionIds(workspaceRoot: string): Promise<string[]> {
   try {
     const files = await readdir(chatDirFor(workspaceRoot));
-    return files.filter((f) => f.endsWith(".jsonl")).map((f) => f.slice(0, -".jsonl".length));
+    return files.filter((fileName) => fileName.endsWith(".jsonl")).map((fileName) => fileName.slice(0, -".jsonl".length));
   } catch {
     return [];
   }
@@ -199,9 +199,9 @@ export async function indexSession(workspaceRoot: string, sessionId: string, dep
   // Upsert into manifest under the in-process lock: replace any
   // prior entry with the same id, sort newest-first by startedAt.
   await updateManifest(workspaceRoot, (current) => {
-    const filtered = current.entries.filter((e) => e.id !== sessionId);
+    const filtered = current.entries.filter((entryItem) => entryItem.id !== sessionId);
     filtered.push(entry);
-    filtered.sort((a, b) => Date.parse(b.startedAt) - Date.parse(a.startedAt));
+    filtered.sort((leftEntry, rightEntry) => Date.parse(rightEntry.startedAt) - Date.parse(leftEntry.startedAt));
     return { version: 1, entries: filtered };
   });
 

package/server/workspace/chat-index/summarizer.ts

@@ -152,10 +152,10 @@ export function validateSummaryResult(obj: unknown): SummaryResult {
   if (!isRecord(obj)) {
     throw new Error("[chat-index] summary result is not an object");
   }
-  const o = obj as Record<string, unknown>;
-  const title = typeof o.title === "string" ? o.title : "";
-  const summary = typeof o.summary === "string" ? o.summary : "";
-  const keywords = Array.isArray(o.keywords) ? o.keywords.filter((k): k is string => typeof k === "string") : [];
+  const record = obj as Record<string, unknown>;
+  const title = typeof record.title === "string" ? record.title : "";
+  const summary = typeof record.summary === "string" ? record.summary : "";
+  const keywords = Array.isArray(record.keywords) ? record.keywords.filter((keyword): keyword is string => typeof keyword === "string") : [];
   return { title, summary, keywords };
 }
 

package/server/workspace/custom-dirs.ts

@@ -4,7 +4,7 @@
 // directories under `data/` and `artifacts/` for organizing files.
 // Claude sees these in the system prompt and routes saves accordingly.
 
-import fs from "fs";
+import { existsSync, mkdirSync, readFileSync } from "fs";
 import path from "path";
 import { workspacePath, WORKSPACE_DIRS } from "./paths.js";
 import { log } from "../system/logger/index.js";
@@ -45,8 +45,8 @@ const CONTROL_CHAR_RE_G = /[\x00-\x1f]/g;
 
 // ── Validation ──────────────────────────────────────────────────
 
-function isValidStructure(v: unknown): v is DirStructure {
-  return v === DIR_STRUCTURES.flat || v === DIR_STRUCTURES.byName || v === DIR_STRUCTURES.byDate;
+function isValidStructure(value: unknown): value is DirStructure {
+  return value === DIR_STRUCTURES.flat || value === DIR_STRUCTURES.byName || value === DIR_STRUCTURES.byDate;
 }
 
 function validatePath(rawPath: string): string | null {
@@ -55,7 +55,7 @@ function validatePath(rawPath: string): string | null {
   const normalized = path.posix.normalize(rawPath);
 
   // Must start with allowed prefix
-  if (!ALLOWED_PREFIXES.some((p) => normalized.startsWith(p))) return null;
+  if (!ALLOWED_PREFIXES.some((prefix) => normalized.startsWith(prefix))) return null;
 
   // No path traversal
   if (normalized.includes("..")) return null;
@@ -64,7 +64,7 @@ function validatePath(rawPath: string): string | null {
   if (path.isAbsolute(normalized)) return null;
 
   // Not a reserved system directory
-  if (RESERVED_DIRS.some((r) => normalized === r || normalized.startsWith(r + "/"))) {
+  if (RESERVED_DIRS.some((reservedDir) => normalized === reservedDir || normalized.startsWith(reservedDir + "/"))) {
     return null;
   }
 
@@ -102,8 +102,8 @@ export function loadCustomDirs(root?: string): CustomDirEntry[] {
   const base = root ?? workspacePath;
   const filePath = path.join(base, CONFIG_FILE);
   try {
-    if (!fs.existsSync(filePath)) return [];
-    const raw = fs.readFileSync(filePath, "utf-8");
+    if (!existsSync(filePath)) return [];
+    const raw = readFileSync(filePath, "utf-8");
     const parsed: unknown = JSON.parse(raw);
     if (!Array.isArray(parsed)) {
       log.warn("custom-dirs", "workspace-dirs.json is not an array");
@@ -112,7 +112,7 @@ export function loadCustomDirs(root?: string): CustomDirEntry[] {
     const entries = parsed
       .slice(0, MAX_ENTRIES)
       .map(validateEntry)
-      .filter((e): e is CustomDirEntry => e !== null);
+      .filter((entry): entry is CustomDirEntry => entry !== null);
 
     const skipped = parsed.length - entries.length;
     if (skipped > 0) {
@@ -132,7 +132,7 @@ export function loadCustomDirs(root?: string): CustomDirEntry[] {
 export function saveCustomDirs(entries: readonly CustomDirEntry[], root?: string): void {
   const base = root ?? workspacePath;
   const filePath = path.join(base, CONFIG_FILE);
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  mkdirSync(path.dirname(filePath), { recursive: true });
   writeFileAtomicSync(filePath, JSON.stringify(entries, null, 2));
   invalidateCache();
 }
@@ -153,8 +153,8 @@ export function validateCustomDirs(raw: unknown): { entries: CustomDirEntry[] }
     if (entry) {
       entries.push(entry);
     } else {
-      const p = isRecord(item) ? String((item as Record<string, unknown>).path ?? "") : "";
-      errors.push(`entry ${i}: invalid path "${p}"`);
+      const itemPath = isRecord(item) ? String((item as Record<string, unknown>).path ?? "") : "";
+      errors.push(`entry ${i}: invalid path "${itemPath}"`);
     }
   });
   if (errors.length > 0) {
@@ -186,7 +186,7 @@ export function ensureCustomDirs(entries: readonly CustomDirEntry[], root?: stri
   const base = root ?? workspacePath;
   for (const entry of entries) {
     const dirPath = path.join(base, entry.path);
-    fs.mkdirSync(dirPath, { recursive: true });
+    mkdirSync(dirPath, { recursive: true });
   }
 }
 
@@ -205,14 +205,14 @@ export function buildCustomDirsPrompt(entries: readonly CustomDirEntry[]): strin
     "",
   ];
 
-  for (const e of entries) {
+  for (const entry of entries) {
     const structureHint =
-      e.structure === DIR_STRUCTURES.byName
+      entry.structure === DIR_STRUCTURES.byName
         ? " (organize by name in subfolders)"
-        : e.structure === DIR_STRUCTURES.byDate
+        : entry.structure === DIR_STRUCTURES.byDate
           ? " (organize by date: YYYY/MM/DD/)"
           : "";
-    lines.push(`- \`${e.path}/\`${structureHint} — ${e.description}`);
+    lines.push(`- \`${entry.path}/\`${structureHint} — ${entry.description}`);
   }
 
   lines.push("");

package/server/workspace/journal/archivist.ts

@@ -60,11 +60,11 @@ export const runClaudeCli: Summarize = async (systemPrompt, userPrompt) => {
       child.kill("SIGKILL");
     }, CLI_TIMEOUT_MS);
 
-    child.stdout.on("data", (d: Buffer) => {
-      stdout += d.toString();
+    child.stdout.on("data", (chunk: Buffer) => {
+      stdout += chunk.toString();
     });
-    child.stderr.on("data", (d: Buffer) => {
-      stderr += d.toString();
+    child.stderr.on("data", (chunk: Buffer) => {
+      stderr += chunk.toString();
     });
 
     child.on("error", (err: Error & { code?: string }) => {
@@ -234,8 +234,8 @@ export function buildDailyUserPrompt(input: DailyArchivistInput): string {
   if (input.existingTopicSummaries.length === 0) {
     parts.push("(none yet)");
   } else {
-    for (const t of input.existingTopicSummaries) {
-      parts.push(`- ${t.slug}`);
+    for (const topicSummary of input.existingTopicSummaries) {
+      parts.push(`- ${topicSummary.slug}`);
     }
   }
   parts.push("");
@@ -244,24 +244,24 @@ export function buildDailyUserPrompt(input: DailyArchivistInput): string {
   // sessions produced, deduped and sorted. Given to the archivist
   // so it can link to them from the summary text.
   const allArtifacts = new Set<string>();
-  for (const s of input.sessionExcerpts) {
-    for (const p of s.artifactPaths) allArtifacts.add(p);
+  for (const sessionExcerpt of input.sessionExcerpts) {
+    for (const artifactPath of sessionExcerpt.artifactPaths) allArtifacts.add(artifactPath);
   }
   parts.push("ARTIFACTS REFERENCED:");
   if (allArtifacts.size === 0) {
     parts.push("(none)");
   } else {
-    for (const p of [...allArtifacts].sort()) {
-      parts.push(`- ${p}`);
+    for (const artifactPath of [...allArtifacts].sort()) {
+      parts.push(`- ${artifactPath}`);
     }
   }
   parts.push("");
 
   parts.push("SESSION EXCERPTS:");
-  for (const s of input.sessionExcerpts) {
-    parts.push(`### session ${s.sessionId} (role: ${s.roleId})`);
-    for (const e of s.events) {
-      parts.push(`- [${e.source}/${e.type}] ${e.content}`);
+  for (const sessionExcerpt of input.sessionExcerpts) {
+    parts.push(`### session ${sessionExcerpt.sessionId} (role: ${sessionExcerpt.roleId})`);
+    for (const eventExcerpt of sessionExcerpt.events) {
+      parts.push(`- [${eventExcerpt.source}/${eventExcerpt.type}] ${eventExcerpt.content}`);
     }
     parts.push("");
   }
@@ -324,10 +324,10 @@ LANGUAGE
 export function buildOptimizationUserPrompt(input: OptimizationInput): string {
   const parts: string[] = [];
   parts.push("CURRENT TOPICS:");
-  for (const t of input.topics) {
-    parts.push(`### ${t.slug}`);
+  for (const topic of input.topics) {
+    parts.push(`### ${topic.slug}`);
     parts.push("```md");
-    parts.push(t.headContent);
+    parts.push(topic.headContent);
     parts.push("```");
     parts.push("");
   }
@@ -352,35 +352,35 @@ import { isRecord } from "../../utils/types.js";
 // guards rather than `as` casts per project conventions.
 export function isDailyArchivistOutput(value: unknown): value is DailyArchivistOutput {
   if (!isRecord(value)) return false;
-  const v = value as Record<string, unknown>;
-  if (typeof v.dailySummaryMarkdown !== "string") return false;
-  if (!Array.isArray(v.topicUpdates)) return false;
-  return v.topicUpdates.every(isTopicUpdate);
+  const recordValue = value as Record<string, unknown>;
+  if (typeof recordValue.dailySummaryMarkdown !== "string") return false;
+  if (!Array.isArray(recordValue.topicUpdates)) return false;
+  return recordValue.topicUpdates.every(isTopicUpdate);
 }
 
 function isTopicUpdate(value: unknown): value is TopicUpdate {
   if (!isRecord(value)) return false;
-  const v = value as Record<string, unknown>;
-  if (typeof v.slug !== "string") return false;
-  if (typeof v.content !== "string") return false;
-  return v.action === "create" || v.action === "append" || v.action === "rewrite";
+  const recordValue = value as Record<string, unknown>;
+  if (typeof recordValue.slug !== "string") return false;
+  if (typeof recordValue.content !== "string") return false;
+  return recordValue.action === "create" || recordValue.action === "append" || recordValue.action === "rewrite";
 }
 
 export function isOptimizationOutput(value: unknown): value is OptimizationOutput {
   if (!isRecord(value)) return false;
-  const v = value as Record<string, unknown>;
-  if (!Array.isArray(v.merges)) return false;
-  if (!Array.isArray(v.archives)) return false;
-  if (!v.merges.every(isTopicMerge)) return false;
-  return v.archives.every((a: unknown) => typeof a === "string");
+  const recordValue = value as Record<string, unknown>;
+  if (!Array.isArray(recordValue.merges)) return false;
+  if (!Array.isArray(recordValue.archives)) return false;
+  if (!recordValue.merges.every(isTopicMerge)) return false;
+  return recordValue.archives.every((archiveSlug: unknown) => typeof archiveSlug === "string");
 }
 
 function isTopicMerge(value: unknown): value is TopicMerge {
   if (!isRecord(value)) return false;
-  const v = value as Record<string, unknown>;
-  if (!Array.isArray(v.from)) return false;
-  if (!v.from.every((f: unknown) => typeof f === "string")) return false;
-  if (typeof v.into !== "string") return false;
-  if (typeof v.newContent !== "string") return false;
+  const recordValue = value as Record<string, unknown>;
+  if (!Array.isArray(recordValue.from)) return false;
+  if (!recordValue.from.every((fromSlug: unknown) => typeof fromSlug === "string")) return false;
+  if (typeof recordValue.into !== "string") return false;
+  if (typeof recordValue.newContent !== "string") return false;
   return true;
 }

package/server/workspace/journal/dailyPass.ts

@@ -81,7 +81,7 @@ export async function runDailyPass(state: JournalState, deps: DailyPassDeps): Pr
   };
 
   // --- Phase 1: figure out what work there is to do ------------------
-  const eligible = (await listSessionMetas(chatDir)).filter((m) => !deps.activeSessionIds.has(m.id));
+  const eligible = (await listSessionMetas(chatDir)).filter((sessionMeta) => !deps.activeSessionIds.has(sessionMeta.id));
   const { dirty } = findDirtySessions(eligible, state.processedSessions);
   if (dirty.length === 0) return { nextState: { ...state }, result };
 
@@ -110,7 +110,7 @@ export async function runDailyPass(state: JournalState, deps: DailyPassDeps): Pr
     ...state,
     knownTopics: [...newTopicsSeen].sort(),
   };
-  const dirtyMetaById = new Map(eligible.map((m) => [m.id, m]));
+  const dirtyMetaById = new Map(eligible.map((sessionMeta) => [sessionMeta.id, sessionMeta]));
   // Process days in chronological order so topic state accumulates
   // naturally: an earlier day's update is visible to the next day.
   const orderedDays = [...dayBuckets.keys()].sort();
@@ -191,7 +191,7 @@ async function processDayAndAdvance(input: ProcessDayInput): Promise<ProcessDayO
   }
 
   const justCompleted = computeJustCompletedSessions(input.date, excerpts, input.sessionToDays, input.dirtyMetaById);
-  const sessionsIngested = justCompleted.map((m) => m.id);
+  const sessionsIngested = justCompleted.map((sessionMeta) => sessionMeta.id);
   const nextState = advanceJournalState(input.nextState, justCompleted, input.newTopicsSeen);
   await persistStateAfterDay(input.workspaceRoot, nextState, input.date);
 
@@ -218,7 +218,9 @@ async function maybeExtractMemory(
   const excerptLines: string[] = [];
   for (const [, byDate] of perSessionExcerpts) {
     for (const [, excerpt] of byDate) {
-      const userLines = excerpt.events.filter((e: SessionEventExcerpt) => e.source === "user").map((e: SessionEventExcerpt) => `[user] ${e.content}`);
+      const userLines = excerpt.events
+        .filter((eventExcerpt: SessionEventExcerpt) => eventExcerpt.source === "user")
+        .map((eventExcerpt: SessionEventExcerpt) => `[user] ${eventExcerpt.content}`);
       if (userLines.length > 0) excerptLines.push(userLines.join("\n"));
     }
   }
@@ -362,7 +364,7 @@ async function refreshTopicSnapshot(workspaceRoot: string, slug: string, existin
   const newBody = await readTopicFile(slug, workspaceRoot);
   if (newBody === null) return;
   const snapshot: ExistingTopicSnapshot = { slug, content: newBody };
-  const idx = existingTopics.findIndex((t) => t.slug === slug);
+  const idx = existingTopics.findIndex((topic) => topic.slug === slug);
   if (idx === -1) existingTopics.push(snapshot);
   else existingTopics[idx] = snapshot;
 }
@@ -427,7 +429,7 @@ export function buildDayBuckets(perSessionExcerpts: ReadonlyMap<string, Readonly
 // to the target topic file's location.
 export function normalizeTopicAction(update: TopicUpdate, existingTopics: readonly ExistingTopicSnapshot[]): TopicUpdate {
   const canonicalSlug = slugify(update.slug);
-  const exists = existingTopics.some((t) => t.slug === canonicalSlug);
+  const exists = existingTopics.some((topic) => topic.slug === canonicalSlug);
   const topicFileWsPath = path.posix.join(WORKSPACE_DIRS.summaries, "topics", `${canonicalSlug}.md`);
   return {
     slug: canonicalSlug,
@@ -527,10 +529,10 @@ async function listSessionMetas(chatDir: string): Promise<SessionFileMeta[]> {
     if (!name.endsWith(".jsonl")) continue;
     const full = path.join(chatDir, name);
     try {
-      const st = await fsp.stat(full);
+      const stats = await fsp.stat(full);
       out.push({
         id: name.replace(/\.jsonl$/, ""),
-        mtimeMs: st.mtimeMs,
+        mtimeMs: stats.mtimeMs,
       });
     } catch {
       // file vanished between readdir and stat — ignore
@@ -607,8 +609,8 @@ export function bucketParsedEvents(events: readonly ParsedEntry[], sessionId: st
       buckets.set(fallbackDate, bucket);
     }
     bucket.events.push(parsed.excerpt);
-    for (const p of parsed.artifactPaths) {
-      if (!bucket.artifactPaths.includes(p)) bucket.artifactPaths.push(p);
+    for (const artifactPath of parsed.artifactPaths) {
+      if (!bucket.artifactPaths.includes(artifactPath)) bucket.artifactPaths.push(artifactPath);
     }
   }
   return buckets;
@@ -662,9 +664,10 @@ export function entryToExcerpt(entry: Record<string, unknown>): SessionEventExce
   // to avoid a NullPointerException-style crash when accessing
   // r.toolName below.
   if (type === EVENT_TYPES.toolResult && isRecord(entry.result)) {
-    const r = entry.result as Record<string, unknown>;
-    const toolName = typeof r.toolName === "string" ? r.toolName : "tool";
-    const label = (typeof r.title === "string" && r.title) || (typeof r.message === "string" && r.message) || "(no message)";
+    const resultRecord = entry.result as Record<string, unknown>;
+    const toolName = typeof resultRecord.toolName === "string" ? resultRecord.toolName : "tool";
+    const label =
+      (typeof resultRecord.title === "string" && resultRecord.title) || (typeof resultRecord.message === "string" && resultRecord.message) || "(no message)";
     return {
       source,
       type,
@@ -682,23 +685,23 @@ export function extractArtifactPaths(entry: Record<string, unknown>): string[] {
   if (entry.type !== "tool_result") return [];
   const result = entry.result;
   if (!isRecord(result)) return [];
-  const r = result as Record<string, unknown>;
-  const data = r.data;
+  const resultRecord = result as Record<string, unknown>;
+  const data = resultRecord.data;
   if (!isRecord(data)) return [];
-  const d = data as Record<string, unknown>;
+  const dataRecord = data as Record<string, unknown>;
   const paths: string[] = [];
 
   // Direct `filePath: string` — presentMulmoScript, presentHtml.
-  if (typeof d.filePath === "string" && d.filePath.length > 0) {
-    paths.push(d.filePath);
+  if (typeof dataRecord.filePath === "string" && dataRecord.filePath.length > 0) {
+    paths.push(dataRecord.filePath);
   }
 
   // Wiki uses `pageName: string` and stores the page at
   // `wiki/pages/<pageName>.md`. The plugin itself doesn't surface
   // the full path in the result, so we synthesise it from the
   // convention established in server/routes/wiki.ts.
-  if (r.toolName === "manageWiki" && typeof d.pageName === "string") {
-    paths.push(`wiki/pages/${d.pageName}.md`);
+  if (resultRecord.toolName === "manageWiki" && typeof dataRecord.pageName === "string") {
+    paths.push(`wiki/pages/${dataRecord.pageName}.md`);
   }
 
   // Paths must be workspace-relative (not absolute, no escape).
@@ -709,18 +712,18 @@ export function extractArtifactPaths(entry: Record<string, unknown>): string[] {
 // Defensive: refuse absolute paths, parent-escapes, or scheme-like
 // strings. Protects against a malformed tool result wedging a
 // filesystem-absolute path into the archivist prompt.
-function isSafeWorkspacePath(p: string): boolean {
-  if (!p) return false;
-  if (p.startsWith("/")) return false;
-  if (p.startsWith("..")) return false;
-  if (p.includes("://")) return false;
+function isSafeWorkspacePath(candidatePath: string): boolean {
+  if (!candidatePath) return false;
+  if (candidatePath.startsWith("/")) return false;
+  if (candidatePath.startsWith("..")) return false;
+  if (candidatePath.includes("://")) return false;
   return true;
 }
 
-function truncate(s: string, max: number): string {
+function truncate(text: string, max: number): string {
   if (max <= 0) return "";
-  if (s.length <= max) return s;
-  return `${s.slice(0, max - 1)}…`;
+  if (text.length <= max) return text;
+  return `${text.slice(0, max - 1)}…`;
 }
 
 async function readAllTopics(workspaceRoot: string): Promise<ExistingTopicSnapshot[]> {

package/server/workspace/journal/diff.ts

@@ -52,8 +52,8 @@ export function findDirtySessions(current: readonly SessionFileMeta[], processed
   }
 
   const missing: string[] = [];
-  for (const id of Object.keys(processed)) {
-    if (!seenNow.has(id)) missing.push(id);
+  for (const sessionId of Object.keys(processed)) {
+    if (!seenNow.has(sessionId)) missing.push(sessionId);
   }
 
   return { dirty, missing };

package/server/workspace/journal/index.ts

@@ -150,17 +150,17 @@ async function runJournalPass(opts: MaybeRunJournalOptions): Promise<void> {
 async function rebuildIndex(workspaceRoot: string): Promise<void> {
   const topics = await walkTopics(workspaceRoot);
   const dailyEntries = await listDailyFilesIO(workspaceRoot);
-  const days: IndexDailyEntry[] = dailyEntries.map((e) => ({
-    date: `${e.year}-${e.month}-${e.day}`,
+  const days: IndexDailyEntry[] = dailyEntries.map((entry) => ({
+    date: `${entry.year}-${entry.month}-${entry.day}`,
   }));
   const archivedCount = await countArchivedIO(workspaceRoot);
-  const md = buildIndexMarkdown({
+  const markdown = buildIndexMarkdown({
     topics,
     days,
     archivedTopicCount: archivedCount,
     builtAtIso: new Date().toISOString(),
   });
-  await writeJournalIndex(md, workspaceRoot);
+  await writeJournalIndex(markdown, workspaceRoot);
 }
 
 async function walkTopics(workspaceRoot: string): Promise<IndexTopicEntry[]> {

package/server/workspace/journal/indexFile.ts

@@ -59,8 +59,8 @@ export function renderTopicsSection(topics: readonly IndexTopicEntry[]): string[
   // Newest-first by last update (topics with no timestamp sort
   // last, ordered alphabetically among themselves for stability).
   const sorted = [...topics].sort(compareTopicsNewestFirst);
-  for (const t of sorted) {
-    lines.push(renderTopicRow(t));
+  for (const topicEntry of sorted) {
+    lines.push(renderTopicRow(topicEntry));
   }
   return lines;
 }
@@ -72,10 +72,14 @@ export function renderRecentDaysSection(days: readonly IndexDailyEntry[], maxRec
     return lines;
   }
   // Newest-first by date string (YYYY-MM-DD sorts lexically).
-  const sorted = [...days].sort((a, b) => (a.date < b.date ? 1 : a.date > b.date ? -1 : 0));
+  const sorted = [...days].sort((leftDay, rightDay) => {
+    if (leftDay.date < rightDay.date) return 1;
+    if (leftDay.date > rightDay.date) return -1;
+    return 0;
+  });
   const head = sorted.slice(0, maxRecent);
-  for (const d of head) {
-    lines.push(renderDailyRow(d));
+  for (const dayEntry of head) {
+    lines.push(renderDailyRow(dayEntry));
   }
   const rest = sorted.length - head.length;
   if (rest > 0) {
@@ -100,37 +104,37 @@ export function renderArchiveSection(archivedTopicCount: number): string[] {
 // timestamps get -Infinity so they sort to the bottom (oldest).
 function topicSortKey(entry: IndexTopicEntry): number {
   if (!entry.lastUpdatedIso) return -Infinity;
-  const ms = Date.parse(entry.lastUpdatedIso);
-  return Number.isNaN(ms) ? -Infinity : ms;
+  const timestampMs = Date.parse(entry.lastUpdatedIso);
+  return Number.isNaN(timestampMs) ? -Infinity : timestampMs;
 }
 
-function compareBySlug(a: IndexTopicEntry, b: IndexTopicEntry): number {
-  if (a.slug < b.slug) return -1;
-  if (a.slug > b.slug) return 1;
+function compareBySlug(leftEntry: IndexTopicEntry, rightEntry: IndexTopicEntry): number {
+  if (leftEntry.slug < rightEntry.slug) return -1;
+  if (leftEntry.slug > rightEntry.slug) return 1;
   return 0;
 }
 
-function compareTopicsNewestFirst(a: IndexTopicEntry, b: IndexTopicEntry): number {
-  const ak = topicSortKey(a);
-  const bk = topicSortKey(b);
+function compareTopicsNewestFirst(leftEntry: IndexTopicEntry, rightEntry: IndexTopicEntry): number {
+  const leftKey = topicSortKey(leftEntry);
+  const rightKey = topicSortKey(rightEntry);
   // Both valid timestamps → compare numerically.
   // One or both invalid (-Infinity) → valid wins; if both invalid,
   // fall through to the slug tie-breaker.
-  const aValid = Number.isFinite(ak);
-  const bValid = Number.isFinite(bk);
-  if (aValid && bValid && bk !== ak) return bk - ak;
-  if (aValid !== bValid) return aValid ? -1 : 1;
+  const leftIsValid = Number.isFinite(leftKey);
+  const rightIsValid = Number.isFinite(rightKey);
+  if (leftIsValid && rightIsValid && rightKey !== leftKey) return rightKey - leftKey;
+  if (leftIsValid !== rightIsValid) return leftIsValid ? -1 : 1;
   // Tie-break on slug for determinism.
-  return compareBySlug(a, b);
+  return compareBySlug(leftEntry, rightEntry);
 }
 
-function renderTopicRow(t: IndexTopicEntry): string {
-  const label = t.title && t.title.trim().length > 0 ? t.title : t.slug;
-  const stamp = t.lastUpdatedIso ? ` — updated ${isoDateOnly(t.lastUpdatedIso)}` : "";
-  return `- [${label}](topics/${t.slug}.md)${stamp}`;
+function renderTopicRow(topicEntry: IndexTopicEntry): string {
+  const label = topicEntry.title && topicEntry.title.trim().length > 0 ? topicEntry.title : topicEntry.slug;
+  const stamp = topicEntry.lastUpdatedIso ? ` — updated ${isoDateOnly(topicEntry.lastUpdatedIso)}` : "";
+  return `- [${label}](topics/${topicEntry.slug}.md)${stamp}`;
 }
 
-function renderDailyRow(d: IndexDailyEntry): string {
-  const [year, month, day] = d.date.split("-");
-  return `- [${d.date}](daily/${year}/${month}/${day}.md)`;
+function renderDailyRow(dayEntry: IndexDailyEntry): string {
+  const [year, month, day] = dayEntry.date.split("-");
+  return `- [${dayEntry.date}](daily/${year}/${month}/${day}.md)`;
 }

package/server/workspace/journal/optimizationPass.ts

@@ -54,7 +54,7 @@ export function planMerges(merges: readonly RawMerge[]): MergePlanItem[] {
   const plans: MergePlanItem[] = [];
   for (const merge of merges) {
     const intoSlug = slugify(merge.into);
-    const fromSlugs = merge.from.map(slugify).filter((s) => s !== intoSlug);
+    const fromSlugs = merge.from.map(slugify).filter((slug) => slug !== intoSlug);
     if (fromSlugs.length === 0) continue;
     plans.push({ intoSlug, fromSlugs, newContent: merge.newContent });
   }
@@ -66,7 +66,7 @@ export function planMerges(merges: readonly RawMerge[]): MergePlanItem[] {
 export function applyRemovedTopics(state: JournalState, removed: ReadonlySet<string>): JournalState {
   return {
     ...state,
-    knownTopics: state.knownTopics.filter((t) => !removed.has(t)),
+    knownTopics: state.knownTopics.filter((topic) => !removed.has(topic)),
   };
 }