mulmoclaude 0.1.2 → 0.3.0

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/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/reference-dirs.ts

@@ -39,11 +39,11 @@ const CONTROL_CHAR_RE_G = /[\x00-\x1f]/g;
 
 // ── Validation ──────────────────────────────────────────────────
 
-function expandHome(p: string): string {
-  if (p.startsWith("~/")) {
-    return path.join(os.homedir(), p.slice(2));
+function expandHome(inputPath: string): string {
+  if (inputPath.startsWith("~/")) {
+    return path.join(os.homedir(), inputPath.slice(2));
   }
-  return p;
+  return inputPath;
 }
 
 function isSensitivePath(absPath: string): boolean {
@@ -59,8 +59,8 @@ function isSensitivePath(absPath: string): boolean {
 
   // Block home-relative sensitive dirs
   if (
-    HOME_RELATIVE_BLOCKED.some((bp) => {
-      const full = path.join(home, bp);
+    HOME_RELATIVE_BLOCKED.some((blockedPath) => {
+      const full = path.join(home, blockedPath);
       return normalized === full || normalized.startsWith(full + path.sep);
     })
   ) {
@@ -68,7 +68,7 @@ function isSensitivePath(absPath: string): boolean {
   }
 
   // Block system directories
-  return SYSTEM_BLOCKED_PREFIXES.some((p) => normalized === p || normalized.startsWith(p + path.sep));
+  return SYSTEM_BLOCKED_PREFIXES.some((blockedPrefix) => normalized === blockedPrefix || normalized.startsWith(blockedPrefix + path.sep));
 }
 
 function sanitizeLabel(raw: string): string {
@@ -76,8 +76,8 @@ function sanitizeLabel(raw: string): string {
   return raw.replace(CONTROL_CHAR_RE_G, " ").trim().slice(0, MAX_LABEL_LENGTH);
 }
 
-function hasTraversalSegment(p: string): boolean {
-  return p.split(path.sep).some((seg) => seg === "..");
+function hasTraversalSegment(inputPath: string): boolean {
+  return inputPath.split(path.sep).some((segment) => segment === "..");
 }
 
 function validateEntry(raw: unknown): ReferenceDirEntry | null {
@@ -117,11 +117,11 @@ export function loadReferenceDirs(root?: string): ReferenceDirEntry[] {
   const entries = parsed
     .slice(0, MAX_ENTRIES)
     .map(validateEntry)
-    .filter((e): e is ReferenceDirEntry => {
-      if (!e) return false;
+    .filter((entry): entry is ReferenceDirEntry => {
+      if (!entry) return false;
       // Deduplicate labels — first entry wins
-      if (seenLabels.has(e.label)) return false;
-      seenLabels.add(e.label);
+      if (seenLabels.has(entry.label)) return false;
+      seenLabels.add(entry.label);
       return true;
     });
 
@@ -155,8 +155,8 @@ export function validateReferenceDirs(raw: unknown): { entries: ReferenceDirEntr
     if (entry) {
       entries.push(entry);
     } else {
-      const p = isRecord(item) ? String((item as Record<string, unknown>).hostPath ?? "") : "";
-      errors.push(`entry ${i}: invalid or blocked path "${p}"`);
+      const hostPath = isRecord(item) ? String((item as Record<string, unknown>).hostPath ?? "") : "";
+      errors.push(`entry ${i}: invalid or blocked path "${hostPath}"`);
     }
   });
   if (errors.length > 0) {
@@ -233,9 +233,9 @@ export function buildReferenceDirsPrompt(entries: readonly ReferenceDirEntry[],
     "",
   ];
 
-  for (const e of entries) {
-    const mountPath = useDocker ? containerPath(e) : e.hostPath;
-    lines.push(`- \`${mountPath}\` — ${e.label}`);
+  for (const entry of entries) {
+    const mountPath = useDocker ? containerPath(entry) : entry.hostPath;
+    lines.push(`- \`${mountPath}\` — ${entry.label}`);
   }
 
   if (!useDocker) {

package/server/workspace/roles.ts

@@ -14,10 +14,10 @@ function withSwitchRole(role: Role): Role {
 
 export function loadCustomRoles(): Role[] {
   return readdirUnderSync(workspacePath, WORKSPACE_DIRS.roles)
-    .filter((f) => f.endsWith(".json"))
-    .flatMap((f) => {
+    .filter((fileName) => fileName.endsWith(".json"))
+    .flatMap((fileName) => {
       try {
-        const raw = readTextUnderSync(workspacePath, path.posix.join(WORKSPACE_DIRS.roles, f));
+        const raw = readTextUnderSync(workspacePath, path.posix.join(WORKSPACE_DIRS.roles, fileName));
         if (!raw) return [];
         return [withSwitchRole(RoleSchema.parse(JSON.parse(raw)))];
       } catch {
@@ -28,10 +28,10 @@ export function loadCustomRoles(): Role[] {
 
 export function loadAllRoles(): Role[] {
   const custom = loadCustomRoles();
-  const builtIn = BUILTIN_ROLES.filter((r) => !custom.find((c) => c.id === r.id));
+  const builtIn = BUILTIN_ROLES.filter((role) => !custom.find((customRole) => customRole.id === role.id));
   return [...builtIn, ...custom];
 }
 
-export function getRole(id: string): Role {
-  return loadAllRoles().find((r) => r.id === id) ?? BUILTIN_ROLES[0];
+export function getRole(roleId: string): Role {
+  return loadAllRoles().find((role) => role.id === roleId) ?? BUILTIN_ROLES[0];
 }

package/server/workspace/skills/discovery.ts

@@ -90,7 +90,7 @@ export async function collectSkillsFromDir(root: string, source: SkillSource): P
     if (skill) results.push(skill);
   }
   // Stable alphabetical order for the UI.
-  results.sort((a, b) => a.name.localeCompare(b.name));
+  results.sort((leftSkill, rightSkill) => leftSkill.name.localeCompare(rightSkill.name));
   return results;
 }
 
@@ -118,8 +118,8 @@ export async function discoverSkills(opts: DiscoverSkillsOptions = {}): Promise<
   // Project overrides user on name collision. Merge by building a
   // map keyed by name, starting with user, overwriting with project.
   const merged = new Map<string, Skill>();
-  for (const s of userSkills) merged.set(s.name, s);
-  for (const s of projectSkills) merged.set(s.name, s);
+  for (const skill of userSkills) merged.set(skill.name, skill);
+  for (const skill of projectSkills) merged.set(skill.name, skill);
 
-  return [...merged.values()].sort((a, b) => a.name.localeCompare(b.name));
+  return [...merged.values()].sort((leftSkill, rightSkill) => leftSkill.name.localeCompare(rightSkill.name));
 }

package/server/workspace/skills/user-tasks.ts

@@ -32,8 +32,8 @@ export interface PersistedUserTask {
   updatedAt: string;
 }
 
-export function loadUserTasks(r?: string): PersistedUserTask[] {
-  return loadRaw<PersistedUserTask>(r);
+export function loadUserTasks(workspaceRoot?: string): PersistedUserTask[] {
+  return loadRaw<PersistedUserTask>(workspaceRoot);
 }
 
 // ── Validation ──────────────────────────────────────────────────
@@ -42,20 +42,20 @@ function isValidDailyTime(value: string): boolean {
   return /^([01]\d|2[0-3]):([0-5]\d)$/.test(value);
 }
 
-function isValidSchedule(s: unknown): s is LocalTaskSchedule {
-  if (!isRecord(s)) return false;
-  const obj = s as Record<string, unknown>;
-  if (obj.type === SCHEDULE_TYPES.interval) {
-    return typeof obj.intervalMs === "number" && obj.intervalMs > 0;
+function isValidSchedule(scheduleValue: unknown): scheduleValue is LocalTaskSchedule {
+  if (!isRecord(scheduleValue)) return false;
+  const scheduleRecord = scheduleValue as Record<string, unknown>;
+  if (scheduleRecord.type === SCHEDULE_TYPES.interval) {
+    return typeof scheduleRecord.intervalMs === "number" && scheduleRecord.intervalMs > 0;
   }
-  if (obj.type === SCHEDULE_TYPES.daily) {
-    return typeof obj.time === "string" && isValidDailyTime(obj.time);
+  if (scheduleRecord.type === SCHEDULE_TYPES.daily) {
+    return typeof scheduleRecord.time === "string" && isValidDailyTime(scheduleRecord.time);
   }
   return false;
 }
 
-function isValidMissedRunPolicy(p: unknown): p is MissedRunPolicy {
-  return p === MISSED_RUN_POLICIES.skip || p === MISSED_RUN_POLICIES.runOnce || p === MISSED_RUN_POLICIES.runAll;
+function isValidMissedRunPolicy(policy: unknown): policy is MissedRunPolicy {
+  return policy === MISSED_RUN_POLICIES.skip || policy === MISSED_RUN_POLICIES.runOnce || policy === MISSED_RUN_POLICIES.runAll;
 }
 
 export type ValidateResult = { kind: "ok"; task: PersistedUserTask } | { kind: "error"; error: string };
@@ -96,44 +96,44 @@ export function validateAndCreate(input: unknown): ValidateResult {
 
 export type UpdateResult = { kind: "ok"; tasks: PersistedUserTask[] } | { kind: "error"; error: string };
 
-export function applyUpdate(tasks: PersistedUserTask[], id: string, patch: unknown): UpdateResult {
+export function applyUpdate(tasks: PersistedUserTask[], taskId: string, patch: unknown): UpdateResult {
   if (!isRecord(patch)) {
     return { kind: "error", error: "request body required" };
   }
-  const idx = tasks.findIndex((t) => t.id === id);
-  if (idx === -1) {
-    return { kind: "error", error: `task not found: ${id}` };
+  const index = tasks.findIndex((task) => task.id === taskId);
+  if (index === -1) {
+    return { kind: "error", error: `task not found: ${taskId}` };
   }
-  const existing = tasks[idx];
+  const existing = tasks[index];
   const updated: PersistedUserTask = { ...existing };
   // patch is validated as non-null object above; spread into Record
-  const p: Record<string, unknown> = { ...patch };
+  const patchRecord: Record<string, unknown> = { ...patch };
 
-  if (typeof p.name === "string" && p.name.trim().length > 0) {
-    updated.name = p.name.trim();
+  if (typeof patchRecord.name === "string" && patchRecord.name.trim().length > 0) {
+    updated.name = patchRecord.name.trim();
   }
-  if (typeof p.description === "string") {
-    updated.description = p.description.trim();
+  if (typeof patchRecord.description === "string") {
+    updated.description = patchRecord.description.trim();
   }
-  if (isValidSchedule(p.schedule)) {
-    updated.schedule = p.schedule;
+  if (isValidSchedule(patchRecord.schedule)) {
+    updated.schedule = patchRecord.schedule;
   }
-  if (isValidMissedRunPolicy(p.missedRunPolicy)) {
-    updated.missedRunPolicy = p.missedRunPolicy;
+  if (isValidMissedRunPolicy(patchRecord.missedRunPolicy)) {
+    updated.missedRunPolicy = patchRecord.missedRunPolicy;
   }
-  if (typeof p.enabled === "boolean") {
-    updated.enabled = p.enabled;
+  if (typeof patchRecord.enabled === "boolean") {
+    updated.enabled = patchRecord.enabled;
   }
-  if (typeof p.roleId === "string") {
-    updated.roleId = p.roleId;
+  if (typeof patchRecord.roleId === "string") {
+    updated.roleId = patchRecord.roleId;
   }
-  if (typeof p.prompt === "string" && p.prompt.trim().length > 0) {
-    updated.prompt = p.prompt.trim();
+  if (typeof patchRecord.prompt === "string" && patchRecord.prompt.trim().length > 0) {
+    updated.prompt = patchRecord.prompt.trim();
   }
   updated.updatedAt = new Date().toISOString();
 
   const next = [...tasks];
-  next[idx] = updated;
+  next[index] = updated;
   return { kind: "ok", tasks: next };
 }
 
@@ -144,7 +144,7 @@ export function applyUpdate(tasks: PersistedUserTask[], id: string, patch: unkno
 let crudMutex: Promise<void> = Promise.resolve();
 
 export async function withUserTaskLock<T>(
-  fn: (tasks: PersistedUserTask[]) => Promise<{
+  lockFn: (tasks: PersistedUserTask[]) => Promise<{
     tasks: PersistedUserTask[];
     result: T;
   }>,
@@ -157,7 +157,7 @@ export async function withUserTaskLock<T>(
   try {
     await prev;
     const current = loadUserTasks();
-    const { tasks: next, result } = await fn(current);
+    const { tasks: next, result } = await lockFn(current);
     await saveUserTasks(next);
     await refreshUserTasks();
     return result;