@linghun/tui 0.1.0

package/dist/chunk-ECFLCY5V.js

@@ -0,0 +1,530 @@
+import {
+  createOutputBlock
+} from "./chunk-AKPXMCVF.js";
+import {
+  writeLine
+} from "./chunk-OMZYPQVA.js";
+
+// src/tui-output-surface.ts
+import { createHash, randomUUID } from "crypto";
+import { mkdir, writeFile } from "fs/promises";
+import { join, relative } from "path";
+import { Writable } from "stream";
+import { TOGGLE_DETAILS_KEYBIND, formatDiagnosticError } from "@linghun/shared";
+var MAX_OUTPUT_BLOCKS = 80;
+var PRESERVE_RECENT_EPHEMERAL_BLOCKS = 12;
+var MAX_LAST_FULL_OUTPUT_CHARS = 12e3;
+var MAX_BLOCK_FULL_TEXT_CHARS = 12e3;
+var LAST_FULL_OUTPUT_PREVIEW_CHARS = 2e3;
+var OUTPUT_MEMORY_ARTIFACT_DIR = "tui-output";
+var MAX_STREAMING_SUMMARY_CHARS = 500;
+function isRuntimeStatusDump(line) {
+  if (line.startsWith("[Linghun] \u4F1A\u8BDD ")) return true;
+  if (line.startsWith("[Linghun] \u6A21\u578B ") && line.includes(" \xB7 \u540E\u53F0 ")) return true;
+  if (line.startsWith("Status: Session ")) return true;
+  if (line.startsWith("Status: Model ") && line.includes(" \xB7 background ")) return true;
+  if (line.includes("\u786E\u8BA4 ") && line.includes("\u540E\u53F0 ")) return true;
+  if (line.includes("Gate ") && line.includes("BG ")) return true;
+  return false;
+}
+var ShellBlockOutput = class extends Writable {
+  constructor(context, blocks, onWrite) {
+    super();
+    this.context = context;
+    this.blocks = blocks;
+    this.onWrite = onWrite;
+  }
+  context;
+  blocks;
+  onWrite;
+  /**
+   * 当前 active 的 assistant streaming block id（keep:true，由
+   * beginAssistantStream 注册）。endAssistantStream 之后清空，下一轮
+   * 再 begin 时换新 id。
+   *
+   * 这条路径专门绕开 _write 的 createOutputBlock + ephemeral splice 逻辑：
+   * 流式 assistant_text_delta 不应被当作普通 writeLine 反复 push/splice，
+   * 否则只会留下最后一片 chunk 而非完整文本。
+   */
+  assistantBlockId;
+  compactOutputMemoryQueue = Promise.resolve();
+  assistantStreamText = "";
+  assistantPreviewText = "";
+  _write(chunk, _encoding, callback) {
+    const text = chunk.toString();
+    const normalized = text.trim();
+    if (normalized) {
+      if (isRuntimeStatusDump(normalized)) {
+        callback();
+        return;
+      }
+      this.blocks.push(createOutputBlock(normalized, this.context.language));
+      if (!this.context.suppressLastFullOutputCapture) {
+        this.context.lastFullOutput = normalized;
+      }
+      this.compactOutputMemory().catch((error) => {
+        void this.appendCompactOutputMemoryWarning(error);
+      });
+      this.onWrite();
+    }
+    callback();
+  }
+  /**
+   * 注册一条 assistant streaming preview id，但 **不立即** 推入 blocks 数组。
+   * 真正的 keep:true block 只在 end/replace 时提交。这样在
+   * thinking-only / 空响应 / 慢请求等场景下，
+   * 主屏不会出现一条空 block 渲染成"没有可见输出。"占位行 —— 等待态由
+   * requestActivityPhase / mapRequestActivityToView 驱动的 ActivityIndicator
+   * 单独负责（"正在思考…" / "Thinking…"）。
+   *
+   * id 由调用方传入（每个 request 用一个稳定 id），便于多轮请求各自占用
+   * 独立 block，互不覆盖。
+   */
+  beginAssistantStream(id) {
+    if (this.assistantBlockId && this.assistantBlockId !== id) {
+      this.clearStreamingPreview(this.assistantBlockId);
+    }
+    this.assistantBlockId = id;
+    this.assistantStreamText = "";
+    this.assistantPreviewText = "";
+    this.context.streamingAssistant = void 0;
+    this.setStreamingPreview(id, "");
+    this.onWrite();
+  }
+  ensureAssistantBlock(id) {
+    const existing = this.blocks.find((b) => b.id === id);
+    if (existing) return existing;
+    const block = createOutputBlock("", this.context.language, id);
+    block.keep = true;
+    block.fullText = "";
+    block.nextAction = void 0;
+    this.blocks.push(block);
+    return block;
+  }
+  /**
+   * 将一段 assistant_text_delta 追加到当前 streaming preview。
+   * - 流式期间只更新 visible-only streaming state，不写历史 ProductBlock
+   * - 正式 assistant block 在 end/replace 时一次性接管，避免重复显示
+   * - 找不到 active id 时静默 fallback 到 _write，保持非交互回退
+   */
+  appendAssistantDelta(text) {
+    if (!text) return;
+    const id = this.assistantBlockId;
+    if (!id) {
+      this._write(text, "utf8", () => {
+      });
+      return;
+    }
+    this.assistantStreamText += text;
+    this.assistantPreviewText = this.assistantStreamText;
+    this.setStreamingPreview(id, this.assistantPreviewText);
+    this.onWrite();
+  }
+  /**
+   * 结束当前 streaming block 的 active 状态。block 保留在 this.blocks
+   * 中作为 transcript row（keep:true 已确保 view-model 不会 slice 它），
+   * 只清掉 active id，下一轮 beginAssistantStream 会换新 id。
+   */
+  endAssistantStream() {
+    const id = this.assistantBlockId;
+    if (id) {
+      const visibleText = this.assistantStreamText || this.assistantPreviewText;
+      if (visibleText) {
+        this.commitAssistantBlock(id, visibleText);
+      }
+      this.clearStreamingPreview(id);
+    }
+    this.assistantBlockId = void 0;
+    this.assistantStreamText = "";
+    this.assistantPreviewText = "";
+    this.compactOutputMemory().catch((error) => {
+      void this.appendCompactOutputMemoryWarning(error);
+    });
+    this.onWrite();
+  }
+  /**
+   * D.13V — Final Answer Gate 在 retry 前丢弃当前 streaming block 的全部累计
+   * 内容。保留 active id，让接下来的 delta 可以重新填回同一条 block；
+   * 同时清掉 lastFullOutput 中可能残留的违规原文，避免 Ctrl+O / details 拉到。
+   */
+  discardAssistantBlock(id) {
+    if (this.assistantBlockId === id) {
+      this.assistantStreamText = "";
+      this.assistantPreviewText = "";
+    }
+    this.clearStreamingPreview(id);
+    const block = this.blocks.find((b) => b.id === id);
+    if (block) {
+      block.fullText = "";
+      block.summary = "";
+    }
+    if (!this.context.suppressLastFullOutputCapture) {
+      this.context.lastFullOutput = void 0;
+    }
+    this.onWrite();
+  }
+  /**
+   * D.13V — Final Answer Gate 在本地降级时把 streaming block 的 fullText
+   * 替换成已经过 buildDowngradedFinalAnswer 处理过的安全文本；同时把
+   * lastFullOutput 同步为同一份安全文本，让 Ctrl+O / details 也只看降级版。
+   */
+  replaceAssistantBlockContent(id, text) {
+    if (this.assistantBlockId === id) {
+      this.assistantStreamText = "";
+      this.assistantPreviewText = "";
+    }
+    this.clearStreamingPreview(id);
+    this.commitAssistantBlock(id, text);
+    if (!this.context.suppressLastFullOutputCapture) {
+      this.context.lastFullOutput = text;
+    }
+    this.compactOutputMemory().catch((error) => {
+      void this.appendCompactOutputMemoryWarning(error);
+    });
+    this.onWrite();
+  }
+  /**
+   * D.13Q-UX Real Smoke Fix v3 — 把一段诊断正文（/mcp status / /index status
+   * 等）显式当作 messageKind=diagnostic block 写入 transcript：
+   *   - 不走 createOutputBlock 的 assistant_text 默认分支，避免被当作普通 AI 正文；
+   *   - 不进入 fail/blocked 状态，不再被任何关键词扫描误伤；
+   *   - 仍累计到 lastFullOutput，让 /details + Ctrl+O 能展开完整诊断。
+   * 调用方应自己保证只用于真正的诊断输出（status / doctor 概要 / state dump）。
+   */
+  writeDiagnosticLine(text) {
+    const normalized = text.replace(/\r/g, "").trim();
+    if (!normalized) return;
+    const firstLine = normalized.split("\n").find((line) => line.trim()) ?? normalized;
+    const nonEmptyLines = normalized.split("\n").filter((line) => line.trim().length > 0).length;
+    const hasMore = normalized.length > 0 && (nonEmptyLines >= 2 || normalized.length > firstLine.length + 16);
+    const detailsHint = this.context.language === "en-US" ? `${TOGGLE_DETAILS_KEYBIND} for details` : `${TOGGLE_DETAILS_KEYBIND} \u67E5\u770B\u5B8C\u6574\u5185\u5BB9`;
+    this.blocks.push({
+      id: `diag-${Date.now()}-${Math.floor(Math.random() * 1e3)}`,
+      kind: "details",
+      status: "info",
+      title: "",
+      summary: firstLine,
+      fullText: normalized,
+      nextAction: hasMore ? detailsHint : void 0,
+      messageKind: "diagnostic"
+    });
+    if (!this.context.suppressLastFullOutputCapture) {
+      this.context.lastFullOutput = normalized;
+    }
+    this.compactOutputMemory().catch((error) => {
+      void this.appendCompactOutputMemoryWarning(error);
+    });
+    this.onWrite();
+  }
+  /**
+   * D.13Q-UX Real Smoke Fix v3 复核 — 显式结构化错误写入路径：
+   *   - 与 createOutputBlock（不再扫关键词）解耦，由调用方明确表态"这是错误"；
+   *   - 走 messageKind="tool_result_error" / kind="error" / status="fail"，
+   *     ProductBlock 命中红边卡片（带 fail marker + tool_result_error tone）；
+   *   - Ctrl+O hint 沿用 v3 规则：只有多行或单行明显超长才挂 errorDetailsHint；
+   *   - fullText 累计到 lastFullOutput，/details + Ctrl+O 能展开完整错误正文。
+   * 调用点限定为真实错误：provider stream error / final no-tools provider error /
+   * slash/tool catch / executeIndexIgnoreWritePlan ignore 写入失败 等。
+   * 普通 writeLine / /mcp status / 普通 assistant 正文不要走这条路径。
+   */
+  writeErrorLine(text, title) {
+    const normalized = text.replace(/\r/g, "").trim();
+    if (!normalized) return;
+    const firstLine = normalized.split("\n").find((line) => line.trim()) ?? normalized;
+    const nonEmptyLines = normalized.split("\n").filter((line) => line.trim().length > 0).length;
+    const hasMore = normalized.length > 0 && (nonEmptyLines >= 2 || normalized.length > firstLine.length + 16);
+    const errorHint = this.context.language === "en-US" ? `${TOGGLE_DETAILS_KEYBIND} for full error` : `${TOGGLE_DETAILS_KEYBIND} \u67E5\u770B\u5B8C\u6574\u9519\u8BEF`;
+    this.blocks.push({
+      id: `err-${Date.now()}-${Math.floor(Math.random() * 1e3)}`,
+      kind: "error",
+      status: "fail",
+      title: title ?? (this.context.language === "en-US" ? "output failed" : "output \u5931\u8D25"),
+      summary: firstLine,
+      fullText: normalized,
+      nextAction: hasMore ? errorHint : void 0,
+      messageKind: "tool_result_error",
+      retrySeconds: this.context.retryInfo?.delaySec,
+      retryAttempt: this.context.retryInfo?.attempt,
+      retryMax: this.context.retryInfo?.max
+    });
+    if (!this.context.suppressLastFullOutputCapture) {
+      this.context.lastFullOutput = normalized;
+    }
+    this.compactOutputMemory().catch((error) => {
+      void this.appendCompactOutputMemoryWarning(error);
+    });
+    this.onWrite();
+  }
+  writeLocalCommandOutputLine(text) {
+    const normalized = text.replace(/\r/g, "").trim();
+    if (!normalized) return;
+    const firstLine = normalized.split("\n").find((line) => line.trim()) ?? normalized;
+    const nonEmptyLines = normalized.split("\n").filter((line) => line.trim().length > 0).length;
+    const hasMore = normalized.length > 0 && (nonEmptyLines >= 2 || normalized.length > firstLine.length + 16);
+    const detailsHint = this.context.language === "en-US" ? `${TOGGLE_DETAILS_KEYBIND} for details` : `${TOGGLE_DETAILS_KEYBIND} \u67E5\u770B\u5B8C\u6574\u5185\u5BB9`;
+    this.blocks.push({
+      id: `local-${Date.now()}-${Math.floor(Math.random() * 1e3)}`,
+      kind: "tool",
+      status: "info",
+      title: "",
+      summary: firstLine,
+      fullText: normalized,
+      nextAction: hasMore ? detailsHint : void 0,
+      messageKind: "local_command_output"
+    });
+    if (!this.context.suppressLastFullOutputCapture) {
+      this.context.lastFullOutput = normalized;
+    }
+    this.compactOutputMemory().catch((error) => {
+      void this.appendCompactOutputMemoryWarning(error);
+    });
+    this.onWrite();
+  }
+  async compactOutputMemory() {
+    this.compactOutputMemoryQueue = this.compactOutputMemoryQueue.then(
+      () => this.compactOutputMemoryOnce()
+    );
+    return this.compactOutputMemoryQueue;
+  }
+  async appendCompactOutputMemoryWarning(error) {
+    if (!this.context.sessionId) {
+      process.stderr.write(
+        `[linghun] compact_output_memory_failed reason=${formatDiagnosticError(error)}
+`
+      );
+      return;
+    }
+    try {
+      await this.context.store.appendEvent(this.context.sessionId, {
+        type: "system_event",
+        id: randomUUID(),
+        level: "warning",
+        message: `compact_output_memory_failed reason=${formatDiagnosticError(error)}`,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } catch (writeError) {
+      process.stderr.write(
+        `[linghun] compact_output_memory_failed reason=${formatDiagnosticError(error)}; warning_write_failed=${formatDiagnosticError(writeError)}
+`
+      );
+    }
+  }
+  commitAssistantBlock(id, text) {
+    if (!text) return void 0;
+    const block = this.ensureAssistantBlock(id);
+    if (!block) return void 0;
+    const firstLine = text.split("\n").find((line) => line.trim()) ?? text;
+    block.fullText = text;
+    block.summary = firstLine.length > MAX_STREAMING_SUMMARY_CHARS ? `${firstLine.slice(0, MAX_STREAMING_SUMMARY_CHARS)}\u2026` : firstLine;
+    if (!this.context.suppressLastFullOutputCapture) {
+      this.context.lastFullOutput = text;
+    }
+    return block;
+  }
+  setStreamingPreview(id, text) {
+    if (!text) {
+      if (this.context.streamingAssistant?.id === id) {
+        this.context.streamingAssistant = void 0;
+      }
+      return;
+    }
+    this.context.streamingAssistant = { id, text };
+  }
+  clearStreamingPreview(id) {
+    if (this.context.streamingAssistant?.id === id) {
+      this.context.streamingAssistant = void 0;
+    }
+  }
+  async compactOutputMemoryOnce() {
+    trimOutputBlocks(this.blocks);
+    try {
+      await compactBlockFullText(this.context, this.blocks);
+      await compactLastFullOutput(this.context);
+    } catch (error) {
+      compactBlockFullTextInMemory(this.blocks, error);
+      compactLastFullOutputInMemory(this.context, error);
+    }
+  }
+};
+function trimOutputBlocks(blocks) {
+  if (blocks.length <= MAX_OUTPUT_BLOCKS) return;
+  const isPreserved = (block) => block.keep === true || block.status === "fail" || block.status === "blocked";
+  const ephemeralIndices = blocks.map((block, index) => isPreserved(block) ? -1 : index).filter((index) => index >= 0);
+  const keepEphemeral = new Set(
+    ephemeralIndices.slice(Math.max(0, ephemeralIndices.length - PRESERVE_RECENT_EPHEMERAL_BLOCKS))
+  );
+  const selected = blocks.filter((block, index) => isPreserved(block) || keepEphemeral.has(index));
+  if (selected.length > MAX_OUTPUT_BLOCKS) {
+    const overflow = selected.length - MAX_OUTPUT_BLOCKS;
+    const removable = selected.map((block, index) => isPreserved(block) ? -1 : index).filter((index) => index >= 0).slice(0, overflow);
+    const drop = new Set(removable);
+    selected.splice(0, selected.length, ...selected.filter((_block, index) => !drop.has(index)));
+  }
+  blocks.splice(0, blocks.length, ...selected);
+}
+async function compactBlockFullText(context, blocks) {
+  for (const block of blocks) {
+    const value = block.fullText;
+    if (!value || value.length <= MAX_BLOCK_FULL_TEXT_CHARS || isCompactedOutputText(value)) {
+      continue;
+    }
+    const artifact = await writeOutputArtifact(context, value);
+    if (block.fullText !== value) {
+      continue;
+    }
+    block.fullText = buildCompactedOutputSummary({
+      tag: "persisted-tui-block-output",
+      relativePath: artifact.relativePath,
+      originalChars: value.length,
+      sha256: artifact.sha256,
+      preview: value.slice(0, LAST_FULL_OUTPUT_PREVIEW_CHARS)
+    });
+  }
+}
+function compactBlockFullTextInMemory(blocks, error) {
+  for (const block of blocks) {
+    const value = block.fullText;
+    if (!value || value.length <= MAX_BLOCK_FULL_TEXT_CHARS || isCompactedOutputText(value)) {
+      continue;
+    }
+    block.fullText = buildCompactedOutputSummary({
+      tag: "compacted-tui-block-output",
+      archiveFailed: error instanceof Error ? error.message : String(error),
+      originalChars: value.length,
+      preview: value.slice(0, LAST_FULL_OUTPUT_PREVIEW_CHARS)
+    });
+  }
+}
+async function compactLastFullOutput(context) {
+  const value = context.lastFullOutput;
+  if (!value || value.length <= MAX_LAST_FULL_OUTPUT_CHARS || isCompactedOutputText(value)) return;
+  const artifact = await writeOutputArtifact(context, value);
+  if (context.lastFullOutput !== value) return;
+  context.lastFullOutput = buildCompactedOutputSummary({
+    tag: "persisted-tui-output",
+    relativePath: artifact.relativePath,
+    originalChars: value.length,
+    sha256: artifact.sha256,
+    preview: value.slice(0, LAST_FULL_OUTPUT_PREVIEW_CHARS)
+  });
+}
+function compactLastFullOutputInMemory(context, error) {
+  const value = context.lastFullOutput;
+  if (!value || value.length <= MAX_LAST_FULL_OUTPUT_CHARS || isCompactedOutputText(value)) return;
+  context.lastFullOutput = buildCompactedOutputSummary({
+    tag: "compacted-tui-output",
+    archiveFailed: error instanceof Error ? error.message : String(error),
+    originalChars: value.length,
+    preview: value.slice(0, LAST_FULL_OUTPUT_PREVIEW_CHARS)
+  });
+}
+async function writeOutputArtifact(context, text) {
+  const sessionId = context.sessionId ?? "unsaved";
+  const dir = join(
+    context.projectPath,
+    ".linghun",
+    "session",
+    OUTPUT_MEMORY_ARTIFACT_DIR,
+    sessionId
+  );
+  await mkdir(dir, { recursive: true });
+  const sha256 = createHash("sha256").update(text).digest("hex");
+  const path = join(dir, `${randomUUID()}-${sha256.slice(0, 12)}.txt`);
+  await writeFile(path, text, "utf8");
+  return {
+    relativePath: relative(context.projectPath, path).replace(/\\/g, "/"),
+    sha256
+  };
+}
+function buildCompactedOutputSummary(input) {
+  return [
+    `<${input.tag}>`,
+    input.relativePath ? `artifactPath: ${input.relativePath}` : "",
+    input.archiveFailed ? `archiveFailed: ${input.archiveFailed}` : "",
+    `originalChars: ${input.originalChars}`,
+    input.sha256 ? `sha256: ${input.sha256}` : "",
+    `previewChars: ${input.preview.length}`,
+    "read: use the artifact path if you need the full TUI output.",
+    "preview:",
+    input.preview,
+    input.originalChars > input.preview.length ? "..." : "",
+    `</${input.tag}>`
+  ].filter((line) => line !== "").join("\n");
+}
+function isCompactedOutputText(value) {
+  return value.startsWith("<persisted-tui-output>") || value.startsWith("<compacted-tui-output>") || value.startsWith("<persisted-tui-block-output>") || value.startsWith("<compacted-tui-block-output>");
+}
+function beginAssistantStream(output, id) {
+  const candidate = output;
+  if (typeof candidate.beginAssistantStream === "function") {
+    candidate.beginAssistantStream(id);
+  }
+}
+function writeAssistantDelta(output, _id, text) {
+  if (!text) return;
+  const candidate = output;
+  if (typeof candidate.appendAssistantDelta === "function") {
+    candidate.appendAssistantDelta(text);
+    return;
+  }
+  output.write(text);
+}
+function endAssistantStream(output) {
+  const candidate = output;
+  if (typeof candidate.endAssistantStream === "function") {
+    candidate.endAssistantStream();
+  }
+}
+function discardAssistantBlock(output, id) {
+  const candidate = output;
+  if (typeof candidate.discardAssistantBlock === "function") {
+    candidate.discardAssistantBlock(id);
+  }
+}
+function replaceAssistantBlockContent(output, id, text) {
+  const candidate = output;
+  if (typeof candidate.replaceAssistantBlockContent === "function") {
+    candidate.replaceAssistantBlockContent(id, text);
+  }
+}
+function writeDiagnosticLine(output, text) {
+  const candidate = output;
+  if (typeof candidate.writeDiagnosticLine === "function") {
+    candidate.writeDiagnosticLine(text);
+    return;
+  }
+  writeLine(output, text);
+}
+function writeErrorLine(output, text, title) {
+  const candidate = output;
+  if (typeof candidate.writeErrorLine === "function") {
+    candidate.writeErrorLine(text, title);
+    return;
+  }
+  writeLine(output, text);
+}
+function writeLocalCommandOutputLine(output, text) {
+  const candidate = output;
+  if (typeof candidate.writeLocalCommandOutputLine === "function") {
+    candidate.writeLocalCommandOutputLine(text);
+    return;
+  }
+  writeLine(output, text);
+}
+function createShellBlockOutputForTest(context, blocks, onWrite = () => {
+}) {
+  return new ShellBlockOutput(context, blocks, onWrite);
+}
+
+export {
+  ShellBlockOutput,
+  beginAssistantStream,
+  writeAssistantDelta,
+  endAssistantStream,
+  discardAssistantBlock,
+  replaceAssistantBlockContent,
+  writeDiagnosticLine,
+  writeErrorLine,
+  writeLocalCommandOutputLine,
+  createShellBlockOutputForTest
+};

package/dist/chunk-EORRZP3F.js

@@ -0,0 +1,109 @@
+import {
+  truncateDisplay
+} from "./chunk-OMZYPQVA.js";
+
+// src/memory-rules-runtime.ts
+import { readFile } from "fs/promises";
+import { dirname, isAbsolute, relative, resolve } from "path";
+var MAX_MEMORY_CHARACTER_COUNT = 4e4;
+var MAX_INCLUDE_DEPTH = 5;
+async function loadMemoryRulesFile(path) {
+  const root = resolve(path);
+  const warnings = [];
+  const includedPaths = [];
+  const content = await loadMemoryFileRecursive(root, root, /* @__PURE__ */ new Set(), 0, includedPaths, warnings);
+  if (content.length <= MAX_MEMORY_CHARACTER_COUNT) {
+    return { content, truncated: false, includedPaths, warnings };
+  }
+  return {
+    content: truncateDisplay(content, MAX_MEMORY_CHARACTER_COUNT),
+    truncated: true,
+    includedPaths,
+    warnings: [...warnings, `memory rules truncated at ${MAX_MEMORY_CHARACTER_COUNT} chars`]
+  };
+}
+function parseMemoryRuleFrontmatter(content) {
+  const match = /^---\r?\n(?<frontmatter>[\s\S]*?)\r?\n---\r?\n?/u.exec(content);
+  if (!match?.groups?.frontmatter) {
+    return { paths: [], body: content };
+  }
+  const paths = [];
+  for (const line of match.groups.frontmatter.split(/\r?\n/u)) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("paths:")) {
+      const inline = trimmed.slice("paths:".length).trim();
+      if (inline.startsWith("[") && inline.endsWith("]")) {
+        paths.push(
+          ...inline.slice(1, -1).split(",").map((item) => cleanFrontmatterPath(item)).filter(Boolean)
+        );
+      }
+      continue;
+    }
+    if (trimmed.startsWith("- ")) {
+      paths.push(cleanFrontmatterPath(trimmed.slice(2)));
+    }
+  }
+  return { paths: [...new Set(paths)], body: content.slice(match[0].length) };
+}
+function shouldApplyMemoryRule(paths, changedPaths) {
+  if (paths.length === 0) return true;
+  return changedPaths.some((file) => paths.some((pattern) => globLikeMatch(pattern, file)));
+}
+async function loadMemoryFileRecursive(root, path, seen, depth, includedPaths, warnings) {
+  const resolved = resolve(path);
+  if (!isInside(dirname(root), resolved) && resolved !== root) {
+    warnings.push(`include skipped outside project rules directory: ${relative(dirname(root), resolved)}`);
+    return "";
+  }
+  if (seen.has(resolved)) {
+    warnings.push(`include cycle skipped: ${relative(dirname(root), resolved)}`);
+    return "";
+  }
+  if (depth > MAX_INCLUDE_DEPTH) {
+    warnings.push(`include depth limit reached at ${relative(dirname(root), resolved)}`);
+    return "";
+  }
+  seen.add(resolved);
+  includedPaths.push(resolved);
+  const raw = await readFile(resolved, "utf8");
+  const withIncludes = await replaceIncludes(root, resolved, raw, seen, depth, includedPaths, warnings);
+  return withIncludes;
+}
+async function replaceIncludes(root, currentPath, content, seen, depth, includedPaths, warnings) {
+  const lines = content.split(/\r?\n/u);
+  const output = [];
+  for (const line of lines) {
+    const match = line.match(/^\s*@include\s+(.+?)\s*$/u);
+    if (!match?.[1]) {
+      output.push(line);
+      continue;
+    }
+    const includePath = resolve(dirname(currentPath), match[1].trim());
+    const included = await loadMemoryFileRecursive(root, includePath, seen, depth + 1, includedPaths, warnings);
+    output.push(included);
+  }
+  return output.join("\n");
+}
+function cleanFrontmatterPath(value) {
+  return value.trim().replace(/^["']|["']$/g, "");
+}
+function globLikeMatch(pattern, file) {
+  const normalizedPattern = pattern.replaceAll("\\", "/");
+  const normalizedFile = file.replaceAll("\\", "/");
+  const optionalDoubleStarSlash = normalizedPattern.startsWith("**/");
+  const escaped = normalizedPattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "::DOUBLE_STAR::").replace(/\*/g, "[^/]*").replace(/::DOUBLE_STAR::/g, ".*");
+  const source = optionalDoubleStarSlash ? escaped.replace(/^\.\*\//u, "(?:.*/)?") : escaped;
+  const nestedOptional = source.replace(/\/\.\*\//gu, "/(?:.*/)?");
+  return new RegExp(`^${nestedOptional}$`, "u").test(normalizedFile);
+}
+function isInside(parent, child) {
+  const rel = relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+
+export {
+  MAX_MEMORY_CHARACTER_COUNT,
+  loadMemoryRulesFile,
+  parseMemoryRuleFrontmatter,
+  shouldApplyMemoryRule
+};