mulmoclaude 0.1.2 → 0.4.0

package/src/router/guards.ts

@@ -7,7 +7,8 @@
 // doesn't push a history entry).
 
 import type { Router } from "vue-router";
-import { VALID_VIEW_MODES } from "../utils/canvas/viewMode";
+import { readPathMatch } from "../composables/useFileSelection";
+import { readWikiRouteTarget } from "../plugins/wiki/route";
 
 // Basic sanity check for a session ID. Real existence verification
 // happens in App.vue's onMounted / loadSession — we can't do async
@@ -18,43 +19,60 @@ 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) => {
-    // Only run guards on the chat route — other routes (redirect, etc.)
-    // don't carry parameters that need sanitizing.
-    if (to.name !== "chat") return;
-
-    // ── sessionId format check ───────────────────────────────────
-    const sessionId = to.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 };
+  router.beforeEach((dest) => {
+    if (dest.name === "chat") {
+      const sessionId = dest.params.sessionId;
+      if (typeof sessionId === "string" && sessionId.length > 0 && !isValidSessionId(sessionId)) {
+        return { name: "chat", params: {}, query: {}, replace: true };
+      }
     }
 
-    // ── view mode whitelist ──────────────────────────────────────
-    const view = to.query.view;
-    if (typeof view === "string" && !VALID_VIEW_MODES.has(view)) {
-      const cleaned = { ...to.query };
-      delete cleaned.view;
-      return { ...to, query: cleaned, replace: true };
+    if (dest.name === "wiki") {
+      // Vue Router decodes `%2F` back to `/` in `route.params.slug`,
+      // so `/wiki/pages/..%2Fsecrets` arrives here as
+      // `{ section: "pages", slug: "../secrets" }`. `readWikiRouteTarget`
+      // returns `null` for unsafe slugs, a missing slug on the `pages`
+      // section, or an unknown section. In any of those cases, bounce
+      // to `/wiki` with `replace: true` so no broken URL lands in
+      // history. Legal targets fall through to the view, where the
+      // route watcher drives the fetch.
+      if (readWikiRouteTarget(dest.params) === null) {
+        return { name: "wiki", params: {}, query: dest.query, replace: true };
+      }
     }
 
-    // ── file path traversal check ────────────────────────────────
-    const filePath = to.query.path;
-    if (typeof filePath === "string") {
-      if (filePath.includes("..") || filePath.startsWith("/")) {
-        const cleaned = { ...to.query };
+    if (dest.name === "files") {
+      // Back-compat: old query-string form `/files?path=foo.md` →
+      // rewrite to the new path form `/files/foo.md`. Silent
+      // replace so bookmarks / log links keep working. Do this
+      // before the traversal check so `?path=../bad` also lands in
+      // the `..` rejection below.
+      const legacyPath = dest.query.path;
+      if (typeof legacyPath === "string" && legacyPath.length > 0) {
+        const cleaned = { ...dest.query };
         delete cleaned.path;
-        return { ...to, query: cleaned, replace: true };
+        return {
+          name: "files",
+          params: { pathMatch: legacyPath.split("/") },
+          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 };
+      // Traversal / absolute-path rejection against the new param.
+      const filePath = readPathMatch(dest.params.pathMatch);
+      if (typeof filePath === "string" && (filePath.includes("..") || filePath.startsWith("/"))) {
+        return {
+          name: "files",
+          params: { pathMatch: [] },
+          query: dest.query,
+          replace: true,
+        };
       }
     }
   });

package/src/router/index.ts

@@ -1,12 +1,9 @@
 // Vue-router setup (history mode — clean URLs without #).
 //
-// The route is /chat/:sessionId? which captures the session the user
-// was looking at. Everything else (view mode, file path, result uuid,
-// role) lives in query parameters and will be wired in later phases.
-//
-// The "/" → "/chat" redirect ensures a fresh browser tab always lands
-// on the chat view with the default (new) session, matching the
-// current pre-router behaviour.
+// Each page has its own route: /chat, /files, /todos, /scheduler,
+// /wiki, /skills, /roles. Layout preference (single vs. stack) is a
+// separate concern persisted in localStorage — it is not part of the
+// URL.
 //
 // History mode requires the server to serve index.html for any path
 // that doesn't match an API route or static file. In production the
@@ -18,28 +15,46 @@ import { createRouter, createWebHistory, type RouteRecordRaw } from "vue-router"
 
 // Stub component that renders nothing. Required by vue-router (every
 // route needs a component) but never actually mounted because App.vue
-// doesn't contain <router-view> in Phase 0.
+// renders based on `route.name` rather than using <router-view>.
 const Stub = defineComponent({ render: () => h("div") });
 
+export const PAGE_ROUTES = {
+  chat: "chat",
+  files: "files",
+  todos: "todos",
+  scheduler: "scheduler",
+  wiki: "wiki",
+  skills: "skills",
+  roles: "roles",
+  history: "history",
+} as const;
+
+export type PageRouteName = (typeof PAGE_ROUTES)[keyof typeof PAGE_ROUTES];
+
 const routes: RouteRecordRaw[] = [
-  {
-    path: "/",
-    redirect: "/chat",
-  },
-  {
-    // sessionId is optional — /chat with no param means "new session"
-    // (the App.vue logic that auto-creates a session continues to
-    // handle this).
-    path: "/chat/:sessionId?",
-    name: "chat",
-    component: Stub,
-  },
-  {
-    // Catch-all: unknown paths redirect to /chat so a stale bookmark
-    // or a typo doesn't show a blank page.
-    path: "/:pathMatch(.*)*",
-    redirect: "/chat",
-  },
+  { path: "/", redirect: "/chat" },
+  { path: "/chat/:sessionId?", name: PAGE_ROUTES.chat, component: Stub },
+  // Files view uses a repeatable catch-all so `/files/a/b/c.md` maps
+  // to `params.pathMatch = ["a", "b", "c.md"]`. Joining on `/` at read
+  // time keeps each segment URL-encoded independently — passing a
+  // string-form catch-all (`:pathMatch(.*)`) would collapse slashes
+  // to `%2F` at push time and mangle deep paths. An empty segment
+  // (`/files`) yields an empty array, which we treat as "no file
+  // selected". See plans/feat-files-path-url.md.
+  { path: "/files/:pathMatch(.*)*", name: PAGE_ROUTES.files, component: Stub },
+  { path: "/todos", name: PAGE_ROUTES.todos, component: Stub },
+  { path: "/scheduler", name: PAGE_ROUTES.scheduler, component: Stub },
+  // Wiki sub-views live on the path rather than in query params so
+  // URLs mirror the filesystem layout (`data/wiki/pages/<slug>.md`)
+  // and stay sibling-safe (no query-key bleed from other routes).
+  // `section` is a closed enum; unknown sections fall through to the
+  // catch-all redirect below. `slug` only applies when `section ===
+  // "pages"`. See plans/feat-wiki-path-urls.md.
+  { path: "/wiki/:section(pages|log|lint-report)?/:slug?", name: PAGE_ROUTES.wiki, component: Stub },
+  { path: "/skills", name: PAGE_ROUTES.skills, component: Stub },
+  { path: "/roles", name: PAGE_ROUTES.roles, component: Stub },
+  { path: "/history", name: PAGE_ROUTES.history, component: Stub },
+  { path: "/:pathMatch(.*)*", redirect: "/chat" },
 ];
 
 const router = createRouter({

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/types/vue-i18n.d.ts

@@ -0,0 +1,20 @@
+// Module augmentation for vue-i18n. Surfaces the English dictionary
+// shape as `DefineLocaleMessage` so IDEs autocomplete key paths on
+// `$t("…")` and `i18n.global.t("…")`. The schema generic on
+// createI18n (src/lib/vue-i18n.ts) handles the `useI18n()` side.
+//
+// Caveat: vue-i18n v11's `t()` overload has a `Key extends string`
+// fallback, so a typo in `useI18n().t("…")` at a deeply-typed call
+// site may still compile. Autocomplete is the main value; strict
+// rejection of unknown keys would require a bespoke wrapper.
+
+import enMessages from "../lang/en";
+
+// Alias so `extends` has an interface-shaped base (typeof in extends
+// position is a syntax error).
+type EnMessages = typeof enMessages;
+
+declare module "vue-i18n" {
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  export interface DefineLocaleMessage extends EnMessages {}
+}

package/src/utils/agent/request.ts

@@ -16,6 +16,24 @@ export interface AgentRequestBody {
   roleId: string;
   chatSessionId: string;
   selectedImageData: string | undefined;
+  // IANA identifier (e.g. "Asia/Tokyo", "America/New_York"). The
+  // server uses this to interpret bare time expressions in the user's
+  // message without asking for clarification every turn. Undefined if
+  // the browser can't resolve a timezone — the server then falls back
+  // to its own local time and asks as before.
+  userTimezone: string | undefined;
+}
+
+// `Intl.DateTimeFormat().resolvedOptions().timeZone` can, in theory,
+// throw in some locked-down environments; wrap so a broken Intl
+// doesn't take down the send path.
+function resolveBrowserTimezone(): string | undefined {
+  try {
+    const zoneId = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    return typeof zoneId === "string" && zoneId.length > 0 ? zoneId : undefined;
+  } catch {
+    return undefined;
+  }
 }
 
 export function buildAgentRequestBody(params: AgentRequestBodyParams): AgentRequestBody {
@@ -24,6 +42,7 @@ export function buildAgentRequestBody(params: AgentRequestBodyParams): AgentRequ
     roleId: params.role.id,
     chatSessionId: params.chatSessionId,
     selectedImageData: params.selectedImageData,
+    userTimezone: resolveBrowserTimezone(),
   };
 }
 
@@ -45,11 +64,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/canvas/layoutMode.ts

@@ -0,0 +1,26 @@
+// Pure helpers for the canvas layout mode.
+//
+// Layout is a user preference — single (sidebar + canvas) vs. stack
+// (no sidebar, full-width canvas). It applies only to the /chat page
+// and persists in localStorage.
+//
+// Pages like /files, /todos, /wiki, /skills, /roles, /scheduler are
+// distinct routes, not layout variants. They live in the router, not
+// here.
+
+export const LAYOUT_MODES = {
+  single: "single",
+  stack: "stack",
+} as const;
+
+export type LayoutMode = (typeof LAYOUT_MODES)[keyof typeof LAYOUT_MODES];
+
+export const LAYOUT_MODE_STORAGE_KEY = "canvas_layout_mode";
+
+// Legacy key from before layout/page were split. Deleted on first
+// read of useLayoutMode — not migrated (fresh start).
+export const LEGACY_VIEW_MODE_STORAGE_KEY = "canvas_view_mode";
+
+export function parseStoredLayoutMode(stored: string | null): LayoutMode {
+  return stored === LAYOUT_MODES.stack ? LAYOUT_MODES.stack : LAYOUT_MODES.single;
+}

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;
 }

package/src/utils/format/frontmatter.ts

@@ -66,15 +66,15 @@ function parseValue(raw: string): FrontmatterValue {
   if (arrayMatch) {
     return arrayMatch[1]
       .split(",")
-      .map((s) => unquote(s.trim()))
-      .filter((s) => s.length > 0);
+      .map((item) => unquote(item.trim()))
+      .filter((item) => item.length > 0);
   }
   return unquote(raw);
 }
 
-function unquote(s: string): string {
-  if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
-    return s.slice(1, -1);
+function unquote(str: string): string {
+  if ((str.startsWith('"') && str.endsWith('"')) || (str.startsWith("'") && str.endsWith("'"))) {
+    return str.slice(1, -1);
   }
-  return s;
+  return str;
 }

package/src/utils/image/cacheBust.ts

@@ -0,0 +1,16 @@
+import { reactive } from "vue";
+
+// Keyed by workspace-relative image path (e.g. "artifacts/images/abc.png").
+// `resolveImageSrc` reads this to append `?v=<bump>` to the URL so consumers
+// (View, Preview) re-fetch when the file on disk has been overwritten in
+// place. The canvas plugin is the current producer — it bumps after each
+// autosave PUT.
+const imageBumps = reactive<Record<string, number>>({});
+
+export function getImageBump(imagePath: string): number {
+  return imageBumps[imagePath] ?? 0;
+}
+
+export function bumpImage(imagePath: string): void {
+  imageBumps[imagePath] = Date.now();
+}

package/src/utils/image/resolve.ts

@@ -1,4 +1,5 @@
 import { API_ROUTES } from "../../config/apiRoutes";
+import { getImageBump } from "./cacheBust";
 
 /** Convert an imageData value to a displayable URL.
  *  Handles both legacy data URIs and workspace-relative file paths. */
@@ -6,3 +7,18 @@ export function resolveImageSrc(imageData: string): string {
   if (imageData.startsWith("data:")) return imageData;
   return `${API_ROUTES.files.raw}?path=${encodeURIComponent(imageData)}`;
 }
+
+/** Same as `resolveImageSrc` but appends the current cache-bust token
+ *  so the browser re-fetches when the file has been overwritten in
+ *  place (e.g. the canvas plugin rewrote it).
+ *
+ *  Use this from display-only consumers (Preview, thumbnail list).
+ *  Avoid inside the canvas View's own `backgroundImage` — changing
+ *  that URL mid-session makes `vue-drawing-canvas` re-fetch on every
+ *  redraw, which races with stroke painting and blanks the canvas. */
+export function resolveImageSrcFresh(imageData: string): string {
+  if (imageData.startsWith("data:")) return imageData;
+  const base = `${API_ROUTES.files.raw}?path=${encodeURIComponent(imageData)}`;
+  const bump = getImageBump(imageData);
+  return bump > 0 ? `${base}&v=${bump}` : base;
+}

package/src/utils/image/rewriteMarkdownImageRefs.ts

@@ -51,7 +51,7 @@ function shouldSkip(url: string): boolean {
 function resolveWorkspacePath(basePath: string, url: string): string | null {
   // Absolute-within-workspace (e.g. "/images/foo.png") — reset base.
   const isAbsolute = url.startsWith("/");
-  const baseSegs = isAbsolute ? [] : basePath.split("/").filter((s) => s !== "" && s !== ".");
+  const baseSegs = isAbsolute ? [] : basePath.split("/").filter((seg) => seg !== "" && seg !== ".");
   const segs = [...baseSegs];
 
   const urlSegs = (isAbsolute ? url.slice(1) : url).split("/");
@@ -76,9 +76,9 @@ function extractBracketedAlt(raw: string): string | null {
   if (!raw.startsWith("![")) return null;
   let depth = 1;
   for (let i = 2; i < raw.length; i++) {
-    const c = raw[i];
-    if (c === "[") depth++;
-    else if (c === "]") {
+    const char = raw[i];
+    if (char === "[") depth++;
+    else if (char === "]") {
       depth--;
       if (depth === 0) return raw.slice(2, i);
     }
@@ -123,7 +123,7 @@ function getContainerChildren(token: Token): Token[] | null {
 // Returns true if the container was rendered via its children, false
 // if the caller should fall back to emitting the parent's raw.
 function renderContainerChildren(raw: string, children: Token[], basePath: string, out: string[]): boolean {
-  const joined = children.map((c) => (c as { raw?: string }).raw ?? "").join("");
+  const joined = children.map((token) => (token as { raw?: string }).raw ?? "").join("");
   if (joined === "") return false;
   const idx = raw.indexOf(joined);
   if (idx < 0) return false;

package/src/utils/markdown/extractFirstH1.ts

@@ -30,8 +30,8 @@ export function extractFirstH1(markdown: string): string | null {
   return null;
 }
 
-function splitLines(s: string): string[] {
-  return s.split(/\r\n|\r|\n/);
+function splitLines(str: string): string[] {
+  return str.split(/\r\n|\r|\n/);
 }
 
 function isInlineSpace(code: number): boolean {

package/src/utils/path/relativeLink.ts

@@ -73,13 +73,13 @@ export function resolveWorkspaceLink(currentFilePath: string, href: string): str
 
 // Drop any trailing #fragment or ?query from a path-like string.
 // Whichever marker comes first wins.
-function stripFragmentAndQuery(s: string): string {
-  const hashIdx = s.indexOf("#");
-  const queryIdx = s.indexOf("?");
-  let end = s.length;
+function stripFragmentAndQuery(str: string): string {
+  const hashIdx = str.indexOf("#");
+  const queryIdx = str.indexOf("?");
+  let end = str.length;
   if (hashIdx !== -1 && hashIdx < end) end = hashIdx;
   if (queryIdx !== -1 && queryIdx < end) end = queryIdx;
-  return s.slice(0, end);
+  return str.slice(0, end);
 }
 
 // If `resolvedPath` points at a chat session log (e.g.
@@ -95,26 +95,26 @@ export function extractSessionIdFromPath(resolvedPath: string): string | null {
   const JSONL_SUFFIX = ".jsonl";
   if (!resolvedPath.startsWith(CHAT_PREFIX)) return null;
   if (!resolvedPath.endsWith(JSONL_SUFFIX)) return null;
-  const id = resolvedPath.slice(CHAT_PREFIX.length, resolvedPath.length - JSONL_SUFFIX.length);
-  if (id.length === 0) return null;
-  if (id.includes("/")) return null;
-  return id;
+  const sessionId = resolvedPath.slice(CHAT_PREFIX.length, resolvedPath.length - JSONL_SUFFIX.length);
+  if (sessionId.length === 0) return null;
+  if (sessionId.includes("/")) return null;
+  return sessionId;
 }
 
 // POSIX-style dirname. The file viewer always uses "/" separators
 // so we don't need to worry about Windows paths.
-function posixDirname(p: string): string {
-  const i = p.lastIndexOf("/");
-  return i === -1 ? "" : p.slice(0, i);
+function posixDirname(path: string): string {
+  const i = path.lastIndexOf("/");
+  return i === -1 ? "" : path.slice(0, i);
 }
 
 // Collapse "./" and "../" in a workspace path. Rejects paths that
 // escape above the workspace root. Returns null for the empty-path
 // case so the caller can bail out. Callers are expected to strip
 // #fragment / ?query before invoking this function.
-function normalizeWorkspacePath(p: string): string | null {
-  if (p.length === 0) return null;
-  const parts = p.split("/");
+function normalizeWorkspacePath(path: string): string | null {
+  if (path.length === 0) return null;
+  const parts = path.split("/");
   const stack: string[] = [];
   for (const part of parts) {
     if (part === "" || part === ".") continue;

package/src/utils/path/workspaceLinkRouter.ts

@@ -0,0 +1,81 @@
+// Classify a workspace-relative link from agent Markdown into a
+// navigation target. Used by TextResponse's click handler to route
+// internal links to the appropriate view (Wiki, Files, Session)
+// instead of letting them fall through to the SPA router.
+//
+// Pure function — no DOM or Vue dependencies, fully unit-testable.
+
+import { isExternalHref, extractSessionIdFromPath } from "./relativeLink";
+
+export type WorkspaceLinkTarget = { kind: "wiki"; slug: string } | { kind: "file"; path: string } | { kind: "session"; sessionId: string };
+
+// Match `data/wiki/pages/<slug>.md` or `wiki/pages/<slug>.md`.
+const WIKI_PAGE_PATTERN = /(?:data\/)?wiki\/pages\/([^/]+)\.md$/;
+
+// Match `conversations/chat/<id>.jsonl` (delegates to extractSessionIdFromPath).
+const CHAT_LOG_PREFIX = "conversations/";
+
+/**
+ * Given a raw href attribute from agent Markdown, return a typed
+ * navigation target, or null if the link is external, anchor-only,
+ * or unresolvable.
+ *
+ * Agent links are typically workspace-root-relative (e.g.
+ * `data/wiki/pages/foo.md`). Relative paths with `../` that escape
+ * the workspace root return null.
+ */
+export function classifyWorkspacePath(href: string): WorkspaceLinkTarget | null {
+  if (!href || isExternalHref(href)) return null;
+  if (href.startsWith("#")) return null;
+
+  // Strip fragment and query
+  const cleaned = stripFragmentAndQuery(href);
+  if (cleaned.length === 0) return null;
+
+  // Normalize path (collapse ./ and ../, reject root-escape)
+  const normalized = normalizePath(cleaned);
+  if (!normalized) return null;
+
+  // Wiki page: data/wiki/pages/<slug>.md
+  const wikiMatch = normalized.match(WIKI_PAGE_PATTERN);
+  if (wikiMatch) {
+    return { kind: "wiki", slug: wikiMatch[1] };
+  }
+
+  // Chat session log: conversations/chat/<id>.jsonl
+  if (normalized.startsWith(CHAT_LOG_PREFIX)) {
+    const chatPath = normalized.slice(CHAT_LOG_PREFIX.length);
+    const sessionId = extractSessionIdFromPath(chatPath);
+    if (sessionId) {
+      return { kind: "session", sessionId };
+    }
+  }
+
+  // Everything else: open in Files view
+  return { kind: "file", path: normalized };
+}
+
+function stripFragmentAndQuery(str: string): string {
+  const hashIdx = str.indexOf("#");
+  const queryIdx = str.indexOf("?");
+  let end = str.length;
+  if (hashIdx !== -1 && hashIdx < end) end = hashIdx;
+  if (queryIdx !== -1 && queryIdx < end) end = queryIdx;
+  return str.slice(0, end);
+}
+
+function normalizePath(raw: string): string | null {
+  if (raw.length === 0) return null;
+  const parts = raw.split("/");
+  const stack: string[] = [];
+  for (const part of parts) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") {
+      if (stack.length === 0) return null;
+      stack.pop();
+      continue;
+    }
+    stack.push(part);
+  }
+  return stack.length === 0 ? null : stack.join("/");
+}

package/src/utils/role/icon.ts

@@ -11,10 +11,10 @@ import type { Role } from "../../config/roles";
 const MATERIAL_ICON_RE = /^[a-z_]+$/;
 
 export function roleIcon(roles: Role[], roleId: string): string {
-  const icon = roles.find((r) => r.id === roleId)?.icon ?? "star";
+  const icon = roles.find((role) => role.id === roleId)?.icon ?? "star";
   return MATERIAL_ICON_RE.test(icon) ? icon : "smart_toy";
 }
 
 export function roleName(roles: Role[], roleId: string): string {
-  return roles.find((r) => r.id === roleId)?.name ?? roleId;
+  return roles.find((role) => role.id === roleId)?.name ?? roleId;
 }

package/src/utils/role/merge.ts

@@ -5,6 +5,6 @@
 import type { Role } from "../../config/roles";
 
 export function mergeRoles(builtin: Role[], custom: Role[]): Role[] {
-  const customIds = new Set(custom.map((r) => r.id));
-  return [...builtin.filter((r) => !customIds.has(r.id)), ...custom];
+  const customIds = new Set(custom.map((role) => role.id));
+  return [...builtin.filter((role) => !customIds.has(role.id)), ...custom];
 }

package/src/utils/role/plugins.ts

@@ -8,5 +8,5 @@ const GEMINI_PLUGINS = new Set<ToolName>([TOOL_NAMES.generateImage, TOOL_NAMES.p
 
 /** Whether the given role uses any plugin that requires a Gemini API key. */
 export function needsGemini(roles: Role[], roleId: string): boolean {
-  return (roles.find((r) => r.id === roleId)?.availablePlugins ?? []).some((p) => GEMINI_PLUGINS.has(p));
+  return (roles.find((role) => role.id === roleId)?.availablePlugins ?? []).some((plugin) => GEMINI_PLUGINS.has(plugin));
 }

package/src/utils/session/sessionFactory.ts

@@ -2,10 +2,10 @@
 
 import type { ActiveSession } from "../../types/session";
 
-export function createEmptySession(id: string, roleId: string): ActiveSession {
+export function createEmptySession(sessionId: string, roleId: string): ActiveSession {
   const now = new Date().toISOString();
   return {
-    id,
+    id: sessionId,
     roleId,
     toolResults: [],
     resultTimestamps: new Map(),