mulmoclaude 2.2.0 → 2.2.1

package/server/workspace/journal/archivist-schemas.ts

@@ -1,4 +1,5 @@
 import { isRecord } from "../../utils/types.js";
+import { WORKSPACE_DIRS } from "../paths.js";
 
 export interface SessionEventExcerpt {
   source: string; // "user" | "assistant" | "tool" | ...
@@ -80,8 +81,8 @@ ARTIFACT LINKS
 - Only link to artifacts listed in "ARTIFACTS REFERENCED". Don't invent paths.
 
 SESSION LINKS
-- When your summary refers to a specific session (the ones listed under "SESSION EXCERPTS" with their \`session <id>\` header), link to that session using \`/chat/<sessionId>.jsonl\`.
-  - Example: "— discussed in [session 550e8400](/chat/550e8400-e29b-41d4-a716-446655440000.jsonl)"
+- When your summary refers to a specific session (the ones listed under "SESSION EXCERPTS" with their \`session <id>\` header), link to that session using \`/${WORKSPACE_DIRS.chat}/<sessionId>.jsonl\`.
+  - Example: "— discussed in [session 550e8400](/${WORKSPACE_DIRS.chat}/550e8400-e29b-41d4-a716-446655440000.jsonl)"
 - The file viewer recognises this pattern and switches the sidebar chat to that session when the link is clicked, so the reader can pick up where the session left off.
 - You do not have to link every session you mention, but linking at least the first reference per session is helpful.
 

package/server/workspace/journal/htmlBlock.ts

@@ -0,0 +1,41 @@
+// CommonMark raw HTML blocks that continue across blank lines (spec types 1-5); other HTML blocks end at a blank line.
+const RAW_TEXT_TAGS = ["script", "pre", "style", "textarea"];
+const MAX_BLOCK_INDENT = 3;
+const COMMENT_OPEN = "<!--";
+const PROCESSING_OPEN = "<?";
+const CDATA_OPEN = "<![CDATA[";
+const DECLARATION_OPEN = "<!";
+
+export interface HtmlBlockEnd {
+  // Lower-cased text whose appearance on a line ends the block.
+  terminator: string;
+}
+
+function startsRawTextTag(lowered: string): string | null {
+  const tag = RAW_TEXT_TAGS.find((name) => lowered.startsWith(`<${name}`));
+  if (tag === undefined) return null;
+  const after = lowered[tag.length + 1];
+  return after === undefined || after === ">" || after === " " || after === "\t" ? tag : null;
+}
+
+function isAsciiLetter(char: string | undefined): boolean {
+  return char !== undefined && char.toLowerCase() !== char.toUpperCase() && char.charCodeAt(0) < 128;
+}
+
+// The terminator when `line` opens a block that can span blank lines, otherwise null.
+export function openHtmlBlock(line: string): HtmlBlockEnd | null {
+  const indent = line.length - line.trimStart().length;
+  if (indent > MAX_BLOCK_INDENT) return null;
+  const lowered = line.trimStart().toLowerCase();
+  const rawTextTag = startsRawTextTag(lowered);
+  if (rawTextTag !== null) return { terminator: `</${rawTextTag}>` };
+  if (lowered.startsWith(COMMENT_OPEN)) return { terminator: "-->" };
+  if (lowered.startsWith(PROCESSING_OPEN)) return { terminator: "?>" };
+  if (lowered.startsWith(CDATA_OPEN.toLowerCase())) return { terminator: "]]>" };
+  return lowered.startsWith(DECLARATION_OPEN) && isAsciiLetter(lowered[DECLARATION_OPEN.length]) ? { terminator: ">" } : null;
+}
+
+// True when the terminator appears on `line`; `searchFrom` skips the opener on the line that opened the block.
+export function endsHtmlBlock(line: string, end: HtmlBlockEnd, searchFrom: number): boolean {
+  return line.toLowerCase().indexOf(end.terminator, searchFrom) !== -1;
+}

package/server/workspace/journal/replaceIfUnchanged.ts

@@ -0,0 +1,10 @@
+import fsp from "node:fs/promises";
+import { writeFileAtomic } from "../../utils/files/atomic.js";
+
+// Compares bytes, not decoded text: invalid UTF-8 and U+FFFD decode to the same string but are different files.
+// Narrows, but cannot close, the window between this read and the rename; a concurrent writer can still win it.
+export async function replaceIfUnchanged(filePath: string, expectedBytes: Buffer, content: string): Promise<boolean> {
+  if (!(await fsp.readFile(filePath)).equals(expectedBytes)) return false;
+  await writeFileAtomic(filePath, content);
+  return true;
+}

package/server/workspace/journal/sessionLinkRepair.ts

@@ -0,0 +1,244 @@
+import path from "node:path";
+import { rewriteMarkdownLinks, splitFragmentAndQuery } from "../../utils/markdown.js";
+import { WORKSPACE_DIRS } from "../paths.js";
+import { endsHtmlBlock, openHtmlBlock, type HtmlBlockEnd } from "./htmlBlock.js";
+
+const JSONL_SUFFIX = ".jsonl";
+// Where summaries written before the prompt fix resolved their session links to.
+const MISCOUNTED_CHAT_DIR = "chat";
+
+export interface SessionLinkRepairResult {
+  content: string;
+  repairedCount: number;
+  // Broken links left as written because their paragraph holds raw HTML or starts indented.
+  skippedCount: number;
+}
+
+// Session id when `resolvedPath` is exactly `chat/<id>.jsonl` at the workspace root.
+export function extractMiscountedSessionId(resolvedPath: string): string | null {
+  const prefix = `${MISCOUNTED_CHAT_DIR}/`;
+  if (!resolvedPath.startsWith(prefix) || !resolvedPath.endsWith(JSONL_SUFFIX)) return null;
+  const sessionId = resolvedPath.slice(prefix.length, resolvedPath.length - JSONL_SUFFIX.length);
+  return sessionId.length === 0 || sessionId.includes("/") ? null : sessionId;
+}
+
+function repairHref(href: string, currentDir: string, sessionExists: (sessionId: string) => boolean): string | null {
+  const { pathPart, suffix } = splitFragmentAndQuery(href);
+  if (pathPart.startsWith("/") || pathPart.includes("://")) return null;
+  const sessionId = extractMiscountedSessionId(path.posix.join(currentDir, pathPart));
+  if (sessionId === null || !sessionExists(sessionId)) return null;
+  const target = `${WORKSPACE_DIRS.chat}/${sessionId}${JSONL_SUFFIX}`;
+  return `${path.posix.relative(currentDir, target)}${suffix}`;
+}
+
+const BACKTICK = "`";
+const HTML_OPEN = "<";
+const FENCE_CHARS = ["`", "~"];
+const MIN_FENCE_LENGTH = 3;
+const MAX_FENCE_INDENT = 3;
+const INDENTED_CODE_SPACES = "    ";
+const TAB = "\t";
+const DIGIT_ZERO = 48;
+const DIGIT_NINE = 57;
+
+interface FenceLine {
+  char: string;
+  length: number;
+  rest: string;
+}
+
+// CommonMark fence line: up to three spaces of indent, then a run of at least three backticks or tildes.
+function parseFenceLine(line: string): FenceLine | null {
+  const indent = line.length - line.trimStart().length;
+  const body = line.slice(indent);
+  const [char] = body;
+  if (indent > MAX_FENCE_INDENT || char === undefined || !FENCE_CHARS.includes(char)) return null;
+  let length = 0;
+  while (body[length] === char) length += 1;
+  return length < MIN_FENCE_LENGTH ? null : { char, length, rest: body.slice(length) };
+}
+
+function opensFence(line: string): FenceLine | null {
+  const fence = parseFenceLine(line);
+  // A backtick fence's info string may not contain a backtick, otherwise the line is inline code.
+  return fence !== null && fence.char === BACKTICK && fence.rest.includes(BACKTICK) ? null : fence;
+}
+
+function closesFence(line: string, open: FenceLine): boolean {
+  const fence = parseFenceLine(line);
+  return fence !== null && fence.char === open.char && fence.length >= open.length && fence.rest.trim() === "";
+}
+
+// Splits text (possibly several lines, never crossing a blank text) into prose and inline-code segments; an unmatched backtick run is plain prose.
+function splitInlineCode(text: string): { text: string; isCode: boolean }[] {
+  const segments: { text: string; isCode: boolean }[] = [];
+  let proseStart = 0;
+  let index = 0;
+  while (index < text.length) {
+    if (text[index] !== BACKTICK) {
+      index += 1;
+      continue;
+    }
+    const runLength = backtickRunLength(text, index);
+    const closeIndex = findClosingRun(text, index + runLength, runLength);
+    if (closeIndex === -1) {
+      index += runLength;
+      continue;
+    }
+    if (index > proseStart) segments.push({ text: text.slice(proseStart, index), isCode: false });
+    segments.push({ text: text.slice(index, closeIndex + runLength), isCode: true });
+    proseStart = closeIndex + runLength;
+    index = proseStart;
+  }
+  if (proseStart < text.length) segments.push({ text: text.slice(proseStart), isCode: false });
+  return segments;
+}
+
+function backtickRunLength(text: string, from: number): number {
+  let end = from;
+  while (text[end] === BACKTICK) end += 1;
+  return end - from;
+}
+
+function findClosingRun(text: string, from: number, runLength: number): number {
+  let index = from;
+  while (index < text.length) {
+    if (text[index] !== BACKTICK) {
+      index += 1;
+      continue;
+    }
+    const length = backtickRunLength(text, index);
+    if (length === runLength) return index;
+    index += length;
+  }
+  return -1;
+}
+
+const QUOTE_MARKER = ">";
+const LIST_BULLETS = ["-", "*", "+"];
+
+function listMarkerLength(text: string): number {
+  const [first] = text;
+  if (first !== undefined && LIST_BULLETS.includes(first)) return text[1] === " " || text[1] === TAB ? 2 : 0;
+  let digits = 0;
+  while (digits < text.length && text.charCodeAt(digits) >= DIGIT_ZERO && text.charCodeAt(digits) <= DIGIT_NINE) digits += 1;
+  const after = text[digits];
+  return digits > 0 && (after === "." || after === ")") && (text[digits + 1] === " " || text[digits + 1] === TAB) ? digits + 2 : 0;
+}
+
+// The line with leading blockquote and list-item markers removed, so a fence or HTML block wrapped in a container is still recognised.
+function stripContainers(line: string): string {
+  let rest = line.trimStart();
+  for (;;) {
+    const markerLength = rest.startsWith(QUOTE_MARKER) ? 1 : listMarkerLength(rest);
+    if (markerLength === 0) return rest;
+    rest = rest.slice(markerLength).trimStart();
+  }
+}
+
+// The line with blockquote markers (and their one optional space) removed, keeping the indent that follows.
+function stripQuoteMarkers(line: string): string {
+  let rest = line;
+  while (rest.trimStart().startsWith(QUOTE_MARKER) && line.length - rest.length <= MAX_FENCE_INDENT) {
+    rest = rest.trimStart().slice(1);
+    if (rest.startsWith(" ")) rest = rest.slice(1);
+  }
+  return rest;
+}
+
+function startsIndentedCode(line: string): boolean {
+  const rest = stripQuoteMarkers(line);
+  return rest.startsWith(INDENTED_CODE_SPACES) || rest.startsWith(TAB);
+}
+
+type BlockKind = "prose" | "fence" | "html" | "blank";
+
+interface Block {
+  kind: BlockKind;
+  text: string;
+}
+
+type RawRegion = { kind: "fence"; fence: FenceLine } | { kind: "html"; end: HtmlBlockEnd };
+
+// The region `line` opens (fenced code, or a raw HTML block that can span blank lines), and whether it already closes on that line.
+function openRegion(rawLine: string): { region: RawRegion; closesHere: boolean } | null {
+  const line = stripContainers(rawLine);
+  const fence = opensFence(line);
+  if (fence !== null) return { region: { kind: "fence", fence }, closesHere: false };
+  const end = openHtmlBlock(line);
+  if (end === null) return null;
+  return { region: { kind: "html", end }, closesHere: endsHtmlBlock(line, end, line.toLowerCase().indexOf("<") + 1) };
+}
+
+function closesRegion(rawLine: string, region: RawRegion): boolean {
+  const line = stripContainers(rawLine);
+  return region.kind === "fence" ? closesFence(line, region.fence) : endsHtmlBlock(line, region.end, 0);
+}
+
+// Splits into raw regions (fenced code, raw HTML blocks), blank lines and paragraphs (runs of non-blank lines).
+function splitBlocks(content: string): Block[] {
+  const blocks: Block[] = [];
+  let paragraph: string[] = [];
+  let region: RawRegion | null = null;
+  const flush = (): void => {
+    if (paragraph.length > 0) blocks.push({ kind: "prose", text: paragraph.join("\n") });
+    paragraph = [];
+  };
+  content.split("\n").forEach((line) => {
+    if (region !== null) {
+      blocks.push({ kind: region.kind, text: line });
+      if (closesRegion(line, region)) region = null;
+      return;
+    }
+    const opened = openRegion(line);
+    if (opened !== null) {
+      flush();
+      blocks.push({ kind: opened.region.kind, text: line });
+      region = opened.closesHere ? null : opened.region;
+    } else if (line.trim() === "") {
+      flush();
+      blocks.push({ kind: "blank", text: line });
+    } else paragraph.push(line);
+  });
+  flush();
+  return blocks;
+}
+
+// A paragraph is edited only when it holds no construct this module does not parse: raw HTML, or an indented-code start.
+// Code spans are parsed (they may cross lines, never a blank line); anything not parsed is left alone rather than guessed at.
+function isEditableParagraph(text: string): boolean {
+  return !text.includes(HTML_OPEN) && !text.split("\n").some(startsIndentedCode);
+}
+
+// Points links that resolve to `<workspace>/chat/<id>.jsonl` at the real `conversations/chat/<id>.jsonl`.
+// A link is left alone when the session file exists in neither place, so links to deleted sessions are not touched.
+// Rewrites link-shaped `[text](href)` destinations in editable prose (the scanner does not tell images, escaped or nested brackets apart). Fenced code, inline code spans (also across lines), paragraphs with raw HTML or an
+// indented-code start, titled links (`[t](href "title")`), reference-style and angle-bracket links are left exactly as written.
+export function repairSessionLinks(fileWsPath: string, content: string, sessionExists: (sessionId: string) => boolean): SessionLinkRepairResult {
+  const currentDir = path.posix.dirname(fileWsPath);
+  let repairedCount = 0;
+  let skippedCount = 0;
+  const repairLinks = (prose: string): string =>
+    rewriteMarkdownLinks(prose, (href) => {
+      const fixed = repairHref(href, currentDir, sessionExists);
+      if (fixed === null) return href;
+      repairedCount += 1;
+      return fixed;
+    });
+  const repairProse = (paragraph: string): string =>
+    splitInlineCode(paragraph)
+      .map((segment) => (segment.isCode ? segment.text : repairLinks(segment.text)))
+      .join("");
+  const countBroken = (prose: string): void => {
+    rewriteMarkdownLinks(prose, (href) => {
+      if (repairHref(href, currentDir, sessionExists) !== null) skippedCount += 1;
+      return href;
+    });
+  };
+  const repaired = splitBlocks(content).map((block) => {
+    if (block.kind === "prose" && isEditableParagraph(block.text)) return repairProse(block.text);
+    if (block.kind === "prose" || block.kind === "html") countBroken(block.text);
+    return block.text;
+  });
+  return { content: repaired.join("\n"), repairedCount, skippedCount };
+}

package/src/plugins/manageSkills/definition.ts

@@ -14,7 +14,7 @@ const toolDefinition: ToolDefinition = {
     `Use the ${TOOL_NAME} tool for the user's skill library:\n\n` +
     `- **list** (default, no args): show every available skill in the canvas.\n` +
     `- **save**: when the user asks to turn the current conversation into a skill (e.g. "skill 化して" / "save this as a skill"), do these steps:\n` +
-    `  1. Read the current chat transcript via the Read tool. The path is \`chat/<session-id>.jsonl\` under the workspace; if you don't know the session id, list \`chat/\` first.\n` +
+    `  1. Read the current chat transcript via the Read tool. The path is \`conversations/chat/<session-id>.jsonl\` under the workspace; if you don't know the session id, list \`conversations/chat/\` first.\n` +
     `  2. Distill the conversation into a short markdown body explaining the steps you took, in second person ("First, do X. Then, do Y."). Keep it focused on the reusable workflow, not the one-off details.\n` +
     `  3. Pick a kebab-case slug (lowercase letters, digits, hyphens; no leading/trailing hyphen; 1-64 chars). If the user gave a name in the request, use it.\n` +
     `  4. Write a one-line description for the YAML frontmatter.\n` +

package/src/utils/path/workspaceLinkRouter.ts

@@ -90,12 +90,11 @@ export function classifyWorkspacePath(href: string): WorkspaceLinkTarget | null
   }
 
   // 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 };
-    }
+  // Summaries written before the prompt used `conversations/chat/` carry `chat/<id>.jsonl`, which only exists on legacy layouts, so accept both.
+  const chatPath = normalized.startsWith(CHAT_LOG_PREFIX) ? normalized.slice(CHAT_LOG_PREFIX.length) : normalized;
+  const sessionId = extractSessionIdFromPath(chatPath);
+  if (sessionId) {
+    return { kind: "session", sessionId };
   }
 
   // Top-level SPA route: leading segment names one of the host's