mulmoclaude 2.1.0 → 2.2.1

package/server/prompts/system/memory-management-atomic.md

@@ -1,33 +1,7 @@
 ## Memory Management
 
-When you learn something from the conversation that would be useful to remember in future sessions, silently save it as a typed entry under `conversations/memory/`. Do not ask permission — just write it.
-
-Each entry is one markdown file with YAML frontmatter:
-
-```yaml
----
-name: <one-line label>
-description: <short blurb shown in the index>
-type: <preference|interest|fact|reference>
----
-<optional longer body>
-```
-
-Pick the type:
-
-- `preference` — durable habit, preference, or convention. Examples: "uses yarn (npm not allowed)", "prefers Emacs", "writes commits in English".
-- `interest` — a topic, hobby, or domain followed long-term. Examples: "AI research papers", "robotics", "Impressionist painting".
-- `fact` — a concrete personal fact that could become stale over time. Examples: "planning a trip to Egypt", "owns a toaster oven", "currently working on BootCamp project".
-- `reference` — pointer to an internal/external resource. Examples: "main repo at ~/ss/llm/mulmoclaude4", "weekly art-exhibitions-watch task".
-
-Filename convention: `<type>_<short-slug>.md` (lowercase ASCII, hyphenated). The frontmatter `type` is the source of truth — the filename is just for ergonomics. After writing the entry, also add a 1-line entry to `conversations/memory/MEMORY.md` of the form:
-
-```
-- [<name>](<filename>) — <description>
-```
+When you learn something from the conversation that would be useful to remember in future sessions, silently save it as a typed entry under `conversations/memory/`. Do not ask permission — just write it. Each entry is one file, `<type>_<short-slug>.md`, with `name` / `description` / `type` frontmatter (type: `preference`, `interest`, `fact` or `reference`), plus a 1-line entry in `conversations/memory/MEMORY.md`. Before writing, `Read` `config/helps/memory-atomic.md` for the exact format, how to pick the type, and the index-line form.
 
 Write when: the fact is durable, not derivable from code or git history, and not already covered by an existing entry. Update an existing entry (and its index line) instead of creating a near-duplicate.
 
 Skip when: it is ephemeral task state, sensitive (credentials, `~/.ssh`, tokens), a duplicate, or something the user asked you to forget.
-
-Keep entries short — name + description + a few lines of body at most. Bias toward fewer high-signal entries rather than exhaustive logging.

package/server/prompts/system/memory-management-topic.md

@@ -1,60 +1,11 @@
 ## Memory Management
 
-When you learn something from the conversation that would be useful to remember in future sessions, silently save it under `conversations/memory/`. Do not ask permission — just write it.
-
-Memory is organised by **topic file**. Each file lives at `conversations/memory/<type>/<topic>.md` and groups related bullets under H2 sections. The system prompt's Memory section above shows the existing topics — pick from that list when adding a new bullet, and only create a new topic when nothing fits.
-
-### Using memory proactively
-
-Before answering, scan the Memory section above for topics related to the user's current message. The H2 tags after each `<type>/<topic>.md` line are searchable hints — match against the user's words (e.g. art / music / travel / tooling). When a topic looks relevant, `Read` the file first and weave the relevant bullets naturally into your answer. Examples:
-
-- The user mentions a trip → check `fact/travel.md` (and any related interest topic) before suggesting destinations.
-- The user asks about a tool / language → check `preference/dev.md` so you don't suggest something they've already vetoed.
-- The user picks up a long-running project → check the matching `fact` or `reference` topic for prior context.
-
-Do NOT announce that you are using memory ("according to your memory…"). The recall is for grounding your answer, not for narration. If nothing in memory is relevant, just answer normally.
-
-Each topic file is one markdown document:
-
-```yaml
----
-type: <preference|interest|fact|reference>
-topic: <slug>
----
-
-# <Topic Name>
-
-## <H2 Section>
-- bullet
-- another bullet
-
-## <Another H2>
-- bullet
-```
-
-Pick the type:
-
-- `preference` — durable habit, preference, or convention. Examples: yarn over npm, prefers Emacs, writes commits in English.
-- `interest` — a topic, hobby, or domain followed long-term. Examples: AI research papers, robotics, Impressionist painting.
-- `fact` — a concrete personal fact that could become stale over time. Examples: planning a trip to Egypt, owns a toaster oven, currently working on BootCamp project.
-- `reference` — pointer to an internal/external resource. Examples: main repo path, weekly art-exhibitions-watch task.
-
-Adding a new bullet:
-
-1. Read the Memory section above. Find the topic file whose subject covers the new bullet.
-2. `Read` that topic file. Pick the H2 section the bullet fits under (or add a new H2 if none fits — H2 sections are optional, you may also append directly under H1 for a small / new topic).
-3. Append your bullet. Keep it short, one line ideally.
-4. `Write` the file back.
-5. `MEMORY.md` is rebuilt during clustering and on explicit `regenerateTopicIndex` calls; individual topic-file writes do NOT update the index immediately. If your bullet adds a new H2 that should appear in the index right away, also `Write` an updated `MEMORY.md` line for that topic.
-
-Creating a new topic file:
-
-- Filename: `<type>/<topic>.md` where `<topic>` is a short lowercase ASCII slug (a-z, 0-9, hyphenated). Examples: `interest/music.md`, `fact/travel.md`, `reference/tasks.md`.
-- Body: H1 with a humanised topic name + bullet(s) under it. H2 sections are optional and best added once the topic has enough material to warrant grouping.
-- After the topic file is written, also `Write` a matching line into `conversations/memory/MEMORY.md` so the new topic is discoverable in the next turn's Memory context. Same caveat as adding an H2: individual topic-file writes do NOT update `MEMORY.md` automatically — the index is only rebuilt during clustering or on explicit `regenerateTopicIndex` calls.
+When you learn something from the conversation that would be useful to remember in future sessions, silently save it under `conversations/memory/`. Do not ask permission — just write it. Memory is organised as topic files at `conversations/memory/<type>/<topic>.md` (type: `preference`, `interest`, `fact` or `reference`); add to an existing topic from the Memory section and create a new one only when nothing fits. Before writing, `Read` `config/helps/memory-topic.md` for the file format, how to pick the type, and the steps — a new topic or H2 also needs a `conversations/memory/MEMORY.md` line.
 
 Write when: the fact is durable, not derivable from code or git history, and not already covered by an existing bullet. Update an existing bullet instead of adding a near-duplicate.
 
 Skip when: it is ephemeral task state, sensitive (credentials, `~/.ssh`, tokens), a duplicate, or something the user asked you to forget.
 
-Keep entries short — bias toward fewer high-signal bullets rather than exhaustive logging.
+### Using memory proactively
+
+Before answering, scan the Memory section above for topics related to the user's current message — the H2 tags after each `<type>/<topic>.md` line are searchable hints. When a topic looks relevant, `Read` the file first and weave the relevant bullets naturally into your answer. Do NOT announce that you are using memory ("according to your memory…"). If nothing in memory is relevant, just answer normally.

package/server/prompts/system/system.md

@@ -55,12 +55,9 @@ When you finish creating, updating, or surfacing a file in your reply (PDF, Mark
 
 Before scheduling a skill / task (`schedule:` in SKILL.md frontmatter — `daily HH:MM` is **UTC**) or changing a system task's frequency, read `config/helps/scheduling.md` for the syntax, recommended intervals, and the overrides API.
 
-## Collection custom views — two incompatible contracts
+## Collection custom views
 
-A collection custom view is an HTML file under the skill's `views/`, registered in `schema.json` `views[]`. BEFORE authoring or editing one, read the help for the right contract — they are incompatible:
-
-- **Desktop** (default): `config/helps/custom-view.md` — the view fetches records itself via the injected token + `dataUrl`.
-- **Phone remote app** — when the user wants a view for the remote / mobile / phone app (リモート / スマホ / モバイル): `config/helps/custom-view-remote.md`. Register it with `target: "mobile"`; records arrive via `await __MC_VIEW.getItems(...)` over a postMessage bridge, and `fetch` is blocked entirely. Do NOT satisfy such a request by baking records into a standalone HTML artifact — author a `target: "mobile"` view (it auto-previews on the desktop in a phone-sized frame).
+Before authoring or editing a collection custom view (an HTML file under the skill's `views/`, registered in `schema.json` `views[]`), read its help — the two contracts are incompatible: `config/helps/custom-view.md` (desktop, the default) or `config/helps/custom-view-remote.md` when the user wants it for the phone / remote / mobile app (リモート / スマホ / モバイル). For the phone, author a `target: "mobile"` view — never bake records into a standalone HTML artifact instead.
 
 ## When a tool call fails, or the user says something is broken
 

package/server/system/config.ts

@@ -117,6 +117,13 @@ export interface AppSettings {
   // still wins, but an icon launch (#2613) passes neither, so for those
   // users this setting is the only way to turn the sink off (#2617).
   macosRemindersEnabled?: boolean;
+
+  // Whether the agent CLI loads Claude Code's USER-level settings (#3406):
+  // `~/.claude` skills, installed plugins and their hooks. On by default, so
+  // skills shared with Claude Code just work; off passes
+  // `--setting-sources project,local`, for a user whose plugins carry so many
+  // skills that their listing dominates every request.
+  loadClaudeUserSettings?: boolean;
 }
 
 const DEFAULT_SETTINGS: AppSettings = { extraAllowedTools: [] };
@@ -137,6 +144,7 @@ export const APP_SETTINGS_KEYS = [
   "journal",
   "pushEnabled",
   "macosRemindersEnabled",
+  "loadClaudeUserSettings",
 ] as const satisfies readonly (keyof AppSettings)[];
 
 export type AppSettingsKey = (typeof APP_SETTINGS_KEYS)[number];
@@ -155,6 +163,7 @@ export const SAFE_SETTINGS_KEYS = [
   "journal",
   "pushEnabled",
   "macosRemindersEnabled",
+  "loadClaudeUserSettings",
 ] as const satisfies readonly AppSettingsKey[];
 
 export type SafeSettingsKey = (typeof SAFE_SETTINGS_KEYS)[number];
@@ -236,6 +245,7 @@ const OPTIONAL_SETTING_VALIDATORS: Record<OptionalAppSettingsKey, (value: unknow
   journal: optional(isJournalMode),
   pushEnabled: isOptionalBoolean,
   macosRemindersEnabled: isOptionalBoolean,
+  loadClaudeUserSettings: isOptionalBoolean,
 };
 
 function hasValidOptionalAppSettings(value: Record<string, unknown>): boolean {
@@ -301,6 +311,8 @@ const isOptionalNullableChatModel = (value: unknown): boolean => value === undef
 const isOptionalNullableChatIndexMode = (value: unknown): boolean => value === undefined || value === null || isChatIndexMode(value);
 const isOptionalNullableJournalMode = (value: unknown): boolean => value === undefined || value === null || isJournalMode(value);
 
+const PATCH_BOOLEAN_KEYS = ["pushEnabled", "macosRemindersEnabled", "loadClaudeUserSettings"] as const satisfies readonly AppSettingsKey[];
+
 export function isAppSettingsPatch(value: unknown): value is AppSettingsPatch {
   if (!isRecord(value)) return false;
   if (value.extraAllowedTools !== undefined && !isStringArray(value.extraAllowedTools)) return false;
@@ -311,9 +323,7 @@ export function isAppSettingsPatch(value: unknown): value is AppSettingsPatch {
   if (value.voiceInput !== undefined && !isVoiceInputSettings(value.voiceInput)) return false;
   if (!isOptionalNullableChatIndexMode(value.chatIndex)) return false;
   if (!isOptionalNullableJournalMode(value.journal)) return false;
-  if (!isOptionalBoolean(value.pushEnabled)) return false;
-  if (!isOptionalBoolean(value.macosRemindersEnabled)) return false;
-  return true;
+  return PATCH_BOOLEAN_KEYS.every((key) => isOptionalBoolean(value[key]));
 }
 
 function parseSettingsRaw(raw: string, file: string): unknown {
@@ -361,6 +371,9 @@ function cloneAppSettings(settings: AppSettings): AppSettings {
   if (settings.macosRemindersEnabled !== undefined) {
     copy.macosRemindersEnabled = settings.macosRemindersEnabled;
   }
+  if (settings.loadClaudeUserSettings !== undefined) {
+    copy.loadClaudeUserSettings = settings.loadClaudeUserSettings;
+  }
   return copy;
 }
 
@@ -401,6 +414,12 @@ export function isMacosRemindersEnabled(settings: AppSettings): boolean {
   return settings.macosRemindersEnabled ?? true;
 }
 
+/** Whether the agent CLI loads Claude Code's user-level settings, default
+ *  `true` — MulmoClaude has always read `~/.claude` skills and plugins. */
+export function isClaudeUserSettingsEnabled(settings: AppSettings): boolean {
+  return settings.loadClaudeUserSettings ?? true;
+}
+
 export function loadSettings(): AppSettings {
   const file = settingsPath();
   const raw = readTextSafeSync(file);
@@ -458,6 +477,9 @@ export function saveSettings(settings: AppSettings): void {
   if (settings.macosRemindersEnabled !== undefined) {
     payload.macosRemindersEnabled = settings.macosRemindersEnabled;
   }
+  if (settings.loadClaudeUserSettings !== undefined) {
+    payload.loadClaudeUserSettings = settings.loadClaudeUserSettings;
+  }
   const serialised = JSON.stringify(payload, null, 2);
   writeFileAtomicSync(settingsPath(), `${serialised}\n`, { mode: 0o600 });
 }

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/components/SettingsModelTab.vue

@@ -32,6 +32,31 @@
       <p class="text-xs text-gray-500">{{ t("settingsModal.modelTab.helperText") }}</p>
     </div>
 
+    <div class="flex items-start gap-3 border-t border-gray-200 pt-3">
+      <input
+        id="settings-model-user-settings"
+        v-model="userSettingsEnabled"
+        type="checkbox"
+        class="mt-1 h-4 w-4"
+        :disabled="savingUserSettings || !loaded"
+        data-testid="settings-model-user-settings-input"
+        @change="saveUserSettings"
+      />
+      <label for="settings-model-user-settings" class="flex-1">
+        <span class="block text-sm font-medium text-gray-800">{{ t("settingsModal.modelTab.userSettingsLabel") }}</span>
+        <span class="block text-xs text-gray-500 mt-0.5">{{ t("settingsModal.modelTab.userSettingsHint") }}</span>
+        <span v-if="skillListing" class="block text-xs text-gray-600 mt-1" data-testid="settings-model-skill-listing">
+          {{ t("settingsModal.modelTab.skillListingSummary", { count: skillListing.skillCount }) }}
+          <template v-if="skillListing.pluginNames.length > 0">
+            {{ t("settingsModal.modelTab.skillListingPlugins", { plugins: skillListing.pluginNames.join(", ") }) }}
+          </template>
+        </span>
+        <span v-if="skillListing?.heavy" class="block text-xs text-amber-700 mt-1" data-testid="settings-model-skill-listing-heavy">
+          {{ t("settingsModal.modelTab.skillListingHeavy") }}
+        </span>
+      </label>
+    </div>
+
     <div v-if="loaded && !errorMessage" class="flex items-center gap-3 text-xs">
       <span :class="colourOf(modelField)" data-testid="settings-model-model-status">
         {{ modelStatusText }}
@@ -63,8 +88,15 @@ const emit = defineEmits<{
   saved: [];
 }>();
 
+interface SkillListing {
+  skillCount: number;
+  pluginNames: string[];
+  heavy: boolean;
+}
+
 interface SettingsResponse {
-  settings: { extraAllowedTools: string[]; effortLevel?: EffortLevel; chatModel?: ChatModel };
+  settings: { extraAllowedTools: string[]; effortLevel?: EffortLevel; chatModel?: ChatModel; loadClaudeUserSettings?: boolean };
+  skillListing?: SkillListing | null;
 }
 
 // One select's whole state, so the save dance below is written once
@@ -87,6 +119,12 @@ const storedModel = ref<ChatModel | "">("");
 const savingModel = ref(false);
 const modelField: SettingField<ChatModel> = { key: "chatModel", draft: modelDraft, stored: storedModel, saving: savingModel };
 
+// Default true matches `isClaudeUserSettingsEnabled` on the server.
+const userSettingsEnabled = ref(true);
+const storedUserSettings = ref(true);
+const savingUserSettings = ref(false);
+const skillListing = ref<SkillListing | null>(null);
+
 const loaded = ref(false);
 const errorMessage = ref("");
 
@@ -119,6 +157,9 @@ async function load(): Promise<void> {
   effortDraft.value = storedEffort.value;
   storedModel.value = response.data.settings.chatModel ?? "";
   modelDraft.value = storedModel.value;
+  storedUserSettings.value = response.data.settings.loadClaudeUserSettings ?? true;
+  userSettingsEnabled.value = storedUserSettings.value;
+  skillListing.value = response.data.skillListing ?? null;
   loaded.value = true;
 }
 
@@ -150,6 +191,22 @@ async function save<T extends string>(field: SettingField<T>): Promise<void> {
   }
 }
 
+async function saveUserSettings(): Promise<void> {
+  if (savingUserSettings.value || userSettingsEnabled.value === storedUserSettings.value) return;
+  const requested = userSettingsEnabled.value;
+  savingUserSettings.value = true;
+  errorMessage.value = "";
+  const response = await apiPut<unknown>(API_ROUTES.config.settings, { loadClaudeUserSettings: requested });
+  savingUserSettings.value = false;
+  if (!response.ok) {
+    errorMessage.value = response.error || t("settingsModal.modelTab.saveError");
+    userSettingsEnabled.value = storedUserSettings.value;
+    return;
+  }
+  storedUserSettings.value = requested;
+  emit("saved");
+}
+
 watch(
   () => props.reloadToken,
   () => {

package/src/config/roles.ts

@@ -42,6 +42,9 @@ export const RoleSchema = z.object({
   icon: z.string(),
   prompt: z.string(),
   availablePlugins: availablePluginsSchema,
+  // `alwaysActive` tools reach every role regardless of `availablePlugins`; a
+  // role that has no use for one names it here to keep its prompt smaller.
+  excludedAlwaysActiveTools: z.array(z.string()).optional(),
   queries: z.array(z.string()).optional(),
   isDebugRole: z.boolean().optional(),
   // Model family this role's sessions run on (#3104). Absent means the role
@@ -96,7 +99,7 @@ export const ROLES: [Role, ...Role[]] = [
   },
   {
     // Keeps the per-turn system prompt small for plain conversation (#3369):
-    // only the form and collection display tools, plus the always-active ones.
+    // only the form and collection display tools, plus `manageCollection`.
     id: "simple",
     name: "Simple",
     icon: "chat_bubble",
@@ -104,6 +107,8 @@ export const ROLES: [Role, ...Role[]] = [
       "You are a concise conversational assistant. Answer directly in the chat, and use the workspace files and collections when the question needs them.\n\n" +
       "This role carries few display tools to keep each turn light. When the user wants a document, slides, an image, or an HTML page, say that the General role can make it and suggest switching.",
     availablePlugins: [TOOL_NAMES.presentForm, TOOL_NAMES.presentCollection],
+    // Plain conversation never pre-generates artifacts in the background.
+    excludedAlwaysActiveTools: [TOOL_NAMES.spawnBackgroundChat],
     queries: ["What can you help me with in this role?", "Summarise what's in my collections.", "Help me think through a decision I'm stuck on."],
   },
   {

package/src/lang/de.ts

@@ -388,6 +388,12 @@ const deMessages = {
       helperText: "Höhere Stufen erlauben mehr Denkzeit, erhöhen aber Latenz und Token-Verbrauch.",
       configured: "Effort: {level}",
       notConfigured: "Nicht gesetzt",
+      userSettingsLabel: "Benutzereinstellungen und Plugins von Claude Code laden",
+      userSettingsHint:
+        "Liest Skills, Plugins und Hooks aus ~/.claude – dieselben, die Claude Code verwendet. Schalten Sie dies aus, wenn installierte Plugins so viele Skills mitbringen, dass jede Anfrage schwer wird; die Skills des Workspace bleiben nutzbar. Gilt ab der nächsten Nachricht. Ausgeschaltet folgt ein nicht gesetztes Modell auch nicht mehr ~/.claude/settings.json.",
+      skillListingSummary: "Im letzten Durchgang geladene Skills: {count}.",
+      skillListingPlugins: "Aus Plugins: {plugins}.",
+      skillListingHeavy: "So viele Skills machen jede Anfrage schwer; ausschalten entfernt die aus ~/.claude.",
       loadError: "Einstellungen konnten nicht geladen werden",
       saveError: "Speichern fehlgeschlagen",
     },