poe-code 3.0.184 → 3.0.186

package/packages/memory/dist/index.js

@@ -0,0 +1,4807 @@
+// packages/memory/src/paths.ts
+import path from "node:path";
+var MEMORY_INDEX_RELPATH = "INDEX.md";
+var MEMORY_LOG_RELPATH = "LOG.md";
+var MEMORY_LOCK_RELPATH = ".lock";
+var MEMORY_PAGES_DIR_RELPATH = "pages";
+var MEMORY_CACHE_DIR_RELPATH = ".cache";
+var MEMORY_INGEST_CACHE_DIR_RELPATH = `${MEMORY_CACHE_DIR_RELPATH}/ingest`;
+var MemoryPathError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MemoryPathError";
+  }
+};
+function resolveMemoryRoot(cwd) {
+  return path.resolve(cwd, ".poe-code", "memory");
+}
+function assertSafeRelPath(input) {
+  const trimmed = input.trim();
+  if (trimmed.length === 0) {
+    throw new MemoryPathError("Expected a non-empty relative path.");
+  }
+  const slashNormalized = trimmed.replaceAll("\\", "/");
+  if (path.posix.isAbsolute(slashNormalized) || path.win32.isAbsolute(slashNormalized)) {
+    throw new MemoryPathError(`Expected a relative path, received absolute path "${input}".`);
+  }
+  const normalized = path.posix.normalize(slashNormalized);
+  if (normalized === "." || normalized.length === 0) {
+    throw new MemoryPathError("Expected a relative path to a file or directory.");
+  }
+  if (normalized === ".." || normalized.startsWith("../")) {
+    throw new MemoryPathError(`Relative path "${input}" cannot escape the memory root.`);
+  }
+  return normalized;
+}
+
+// packages/memory/src/resolve-root.ts
+import path8 from "node:path";
+
+// packages/poe-code-config/src/schema.ts
+function defineScope(scope, schema) {
+  return {
+    scope,
+    schema
+  };
+}
+
+// packages/poe-code-config/src/plan-scope.ts
+var planConfigScope = defineScope("plan", {
+  plan_directory: {
+    type: "string",
+    default: "docs/plans",
+    env: "POE_PLAN_DIRECTORY",
+    doc: "Directory where planning documents are stored"
+  }
+});
+
+// packages/poe-code-config/src/store.ts
+import path6 from "node:path";
+
+// packages/config-extends/src/discover.ts
+import path2 from "node:path";
+async function findBase(name, bases, fs13) {
+  const checkedPaths = [];
+  for (const basePath of bases) {
+    for (const extension of [".md", ".yaml", ".yml", ".json"]) {
+      const filePath = path2.join(basePath, `${name}${extension}`);
+      checkedPaths.push(filePath);
+      try {
+        return {
+          content: await fs13.readFile(filePath, "utf8"),
+          filePath
+        };
+      } catch (error) {
+        if (hasCode(error, "ENOENT")) {
+          continue;
+        }
+        throw error;
+      }
+    }
+  }
+  throw new Error(`Base "${name}" not found.
+Checked paths:
+- ${checkedPaths.join("\n- ")}`);
+}
+function hasCode(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+
+// packages/config-extends/src/parse.ts
+import path3 from "node:path";
+import matter from "gray-matter";
+import { parse as parseYaml } from "yaml";
+function parseDocument(content, filePath) {
+  const normalizedContent = stripBom(content);
+  const format = detectFormat(normalizedContent, filePath);
+  const data = format === "markdown" ? parseMarkdown(normalizedContent) : toData(format === "json" ? JSON.parse(normalizedContent) : parseYaml(normalizedContent));
+  const hasExtendsField = Object.hasOwn(data, "extends");
+  const extendsValue = data.extends === true;
+  delete data.extends;
+  return {
+    data,
+    format,
+    extends: extendsValue,
+    hasExtendsField
+  };
+}
+function detectFormat(content, filePath) {
+  const extension = path3.extname(filePath).toLowerCase();
+  if (extension === ".md") {
+    return "markdown";
+  }
+  if (extension === ".yaml" || extension === ".yml") {
+    return "yaml";
+  }
+  if (extension === ".json") {
+    return "json";
+  }
+  if (content.startsWith("{")) {
+    return "json";
+  }
+  if (content.startsWith("---\n") || content.startsWith("---\r\n")) {
+    return "markdown";
+  }
+  return "yaml";
+}
+function parseMarkdown(content) {
+  const document = matter(content);
+  return {
+    ...toData(document.data),
+    prompt: document.content
+  };
+}
+function toData(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return { ...value };
+}
+function stripBom(content) {
+  if (!content.startsWith("\uFEFF")) {
+    return content;
+  }
+  return content.slice(1);
+}
+
+// packages/config-extends/src/merge.ts
+function mergeLayers(layers) {
+  return mergeObjectLayers(layers, []);
+}
+function mergeObjectLayers(layers, path25) {
+  const data = {};
+  const sources = {};
+  for (const key of collectKeys(layers)) {
+    const resolved = resolveKey(layers, key, path25);
+    if (resolved === void 0) {
+      continue;
+    }
+    data[key] = resolved.value;
+    Object.assign(sources, resolved.sources);
+  }
+  return { data, sources };
+}
+function collectKeys(layers) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const layer of layers) {
+    for (const key of Object.keys(layer.data)) {
+      keys.add(key);
+    }
+  }
+  return [...keys];
+}
+function resolveKey(layers, key, path25) {
+  let winningSource;
+  let winningValue;
+  const objectLayers = [];
+  for (const layer of layers) {
+    const candidate = layer.data[key];
+    if (!isWinningCandidate(key, candidate)) {
+      continue;
+    }
+    if (winningSource === void 0) {
+      winningSource = layer.source;
+      winningValue = candidate;
+      if (isPlainObject(candidate)) {
+        objectLayers.push({
+          source: layer.source,
+          data: candidate
+        });
+      }
+      continue;
+    }
+    if (isPlainObject(winningValue) && isPlainObject(candidate)) {
+      objectLayers.push({
+        source: layer.source,
+        data: candidate
+      });
+    }
+  }
+  if (winningSource === void 0) {
+    return void 0;
+  }
+  const fullPath = buildPath(path25, key);
+  if (isPlainObject(winningValue)) {
+    const merged = mergeObjectLayers(objectLayers, [...path25, key]);
+    return {
+      value: merged.data,
+      sources: {
+        [fullPath]: winningSource,
+        ...merged.sources
+      }
+    };
+  }
+  return {
+    value: cloneValue(winningValue),
+    sources: {
+      [fullPath]: winningSource
+    }
+  };
+}
+function isWinningCandidate(key, value) {
+  if (value === void 0) {
+    return false;
+  }
+  if (key === "prompt" && value === "") {
+    return false;
+  }
+  return true;
+}
+function buildPath(path25, key) {
+  return [...path25, key].join(".");
+}
+function isPlainObject(value) {
+  if (value === null || Array.isArray(value) || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function cloneValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => cloneValue(entry));
+  }
+  if (!isPlainObject(value)) {
+    return value;
+  }
+  const clone = Object.create(Object.getPrototypeOf(value));
+  for (const [key, entry] of Object.entries(value)) {
+    clone[key] = cloneValue(entry);
+  }
+  return clone;
+}
+
+// packages/config-extends/src/resolve.ts
+import path4 from "node:path";
+var MAX_EXTENDS_DEPTH = 5;
+var YIELD_TOKEN = "{{yield}}";
+async function resolve(chain, options) {
+  const { baseLayers, documentIndex, documentLayer } = classifyChain(chain);
+  const parsedDocument = parseDocument(documentLayer.content, documentLayer.filePath);
+  const resolvedBase = shouldResolveBase(parsedDocument, options.autoExtend) ? await resolveBaseChain({
+    name: documentLayer.baseName ?? getBaseName(documentLayer.filePath),
+    baseLayers,
+    options,
+    optional: !parsedDocument.extends,
+    visited: /* @__PURE__ */ new Set([documentLayer.filePath]),
+    depth: 1
+  }) : void 0;
+  const composedPrompt = composePromptChain(
+    {
+      source: documentLayer.source,
+      data: parsedDocument.data
+    },
+    resolvedBase?.layers ?? []
+  );
+  const merged = mergeLayers([
+    ...collectDataLayers(chain.slice(0, documentIndex)),
+    {
+      source: documentLayer.source,
+      data: withResolvedPrompt(parsedDocument.data, composedPrompt?.prompt)
+    },
+    ...stripResolvedBasePrompts(resolvedBase?.layers ?? [], composedPrompt?.consumedBaseIndexes ?? /* @__PURE__ */ new Set()),
+    ...collectDataLayers(chain.slice(documentIndex + 1))
+  ]);
+  if (composedPrompt !== void 0 && merged.sources.prompt === documentLayer.source && composedPrompt.source !== void 0) {
+    merged.sources.prompt = composedPrompt.source;
+  }
+  return {
+    data: merged.data,
+    sources: merged.sources,
+    chain: [documentLayer.filePath, ...resolvedBase?.chain ?? []]
+  };
+}
+function classifyChain(chain) {
+  const baseLayers = [];
+  const documentLayers = [];
+  for (const [index, layer] of chain.entries()) {
+    if (isDataLayer(layer)) {
+      continue;
+    }
+    if (isDocumentLayer(layer)) {
+      documentLayers.push({ index, layer });
+      continue;
+    }
+    if (isBaseLayer(layer)) {
+      baseLayers.push(layer);
+    }
+  }
+  if (documentLayers.length !== 1) {
+    throw new Error(`Exactly one document layer is required, received ${documentLayers.length}.`);
+  }
+  return {
+    baseLayers,
+    documentIndex: documentLayers[0].index,
+    documentLayer: documentLayers[0].layer
+  };
+}
+async function resolveBaseChain({
+  name,
+  baseLayers,
+  options,
+  optional,
+  visited,
+  depth
+}) {
+  if (depth > MAX_EXTENDS_DEPTH) {
+    throw new Error(`Maximum extends depth exceeded (${MAX_EXTENDS_DEPTH}).`);
+  }
+  let discoveredBase;
+  try {
+    discoveredBase = await findBase(
+      name,
+      baseLayers.map((layer) => layer.path),
+      options.fs
+    );
+  } catch (error) {
+    if (optional && isBaseNotFoundError(error)) {
+      return void 0;
+    }
+    throw error;
+  }
+  if (visited.has(discoveredBase.filePath)) {
+    throw new Error(
+      `Circular extends detected.
+Visited files:
+- ${[...visited, discoveredBase.filePath].join("\n- ")}`
+    );
+  }
+  const matchedBaseIndex = baseLayers.findIndex(
+    (layer) => layer.path === path4.dirname(discoveredBase.filePath)
+  );
+  if (matchedBaseIndex === -1) {
+    throw new Error(`Resolved base is outside configured base paths: ${discoveredBase.filePath}`);
+  }
+  const parsedBase = parseDocument(discoveredBase.content, discoveredBase.filePath);
+  const nextVisited = new Set(visited);
+  nextVisited.add(discoveredBase.filePath);
+  const nestedBase = parsedBase.extends ? await resolveBaseChain({
+    name: getBaseName(discoveredBase.filePath),
+    baseLayers: baseLayers.slice(matchedBaseIndex + 1),
+    options,
+    optional: false,
+    visited: nextVisited,
+    depth: depth + 1
+  }) : void 0;
+  return {
+    layers: [
+      {
+        source: baseLayers[matchedBaseIndex].source,
+        data: parsedBase.data
+      },
+      ...nestedBase?.layers ?? []
+    ],
+    chain: [discoveredBase.filePath, ...nestedBase?.chain ?? []]
+  };
+}
+function collectDataLayers(chain) {
+  return chain.filter(isDataLayer);
+}
+function composePromptChain(documentLayer, baseLayers) {
+  const documentPrompt = documentLayer.data.prompt;
+  if (documentPrompt !== void 0 && typeof documentPrompt !== "string") {
+    return void 0;
+  }
+  if (documentPrompt !== void 0) {
+    assertValidYieldCount(documentPrompt);
+  }
+  let prompt = documentPrompt;
+  let source = prompt === void 0 || prompt === "" ? void 0 : documentLayer.source;
+  const consumedBaseIndexes = /* @__PURE__ */ new Set();
+  for (const [index, layer] of baseLayers.entries()) {
+    const candidate = layer.data.prompt;
+    if (candidate === void 0) {
+      continue;
+    }
+    if (typeof candidate !== "string") {
+      break;
+    }
+    assertValidYieldCount(candidate);
+    consumedBaseIndexes.add(index);
+    prompt = composeAdjacentPrompts(prompt, candidate);
+    if (source === void 0 && candidate !== "") {
+      source = layer.source;
+    }
+  }
+  if (prompt !== void 0 && prompt.includes(YIELD_TOKEN)) {
+    throw new Error('Final resolved prompt contains an unresolved "{{yield}}" token.');
+  }
+  if (prompt === void 0) {
+    return void 0;
+  }
+  return {
+    consumedBaseIndexes,
+    prompt,
+    source
+  };
+}
+function composeAdjacentPrompts(high, low) {
+  if (high === void 0 || high === "") {
+    return low.includes(YIELD_TOKEN) ? replaceYield(low, "") : low;
+  }
+  if (high.includes(YIELD_TOKEN)) {
+    return replaceYield(high, low);
+  }
+  if (low.includes(YIELD_TOKEN)) {
+    return replaceYield(low, high);
+  }
+  return high;
+}
+function replaceYield(prompt, replacement) {
+  return prompt.replace(YIELD_TOKEN, replacement);
+}
+function assertValidYieldCount(prompt) {
+  if (countYieldTokens(prompt) > 1) {
+    throw new Error('Prompt composition supports exactly one "{{yield}}" token per prompt.');
+  }
+}
+function countYieldTokens(prompt) {
+  return prompt.split(YIELD_TOKEN).length - 1;
+}
+function withResolvedPrompt(data, prompt) {
+  if (prompt === void 0) {
+    return data;
+  }
+  return {
+    ...data,
+    prompt
+  };
+}
+function stripResolvedBasePrompts(layers, consumedBaseIndexes) {
+  return layers.map((layer, index) => {
+    if (!consumedBaseIndexes.has(index) || typeof layer.data.prompt !== "string") {
+      return layer;
+    }
+    const { prompt: ignoredPrompt, ...data } = layer.data;
+    void ignoredPrompt;
+    return {
+      source: layer.source,
+      data
+    };
+  });
+}
+function getBaseName(filePath) {
+  return path4.basename(filePath, path4.extname(filePath));
+}
+function shouldResolveBase(parsedDocument, autoExtend) {
+  return parsedDocument.extends || autoExtend === true && !parsedDocument.hasExtendsField;
+}
+function isBaseNotFoundError(error) {
+  return error instanceof Error && error.message.startsWith('Base "') && error.message.includes('" not found.\nChecked paths:');
+}
+function isDataLayer(layer) {
+  return "data" in layer;
+}
+function isDocumentLayer(layer) {
+  return "filePath" in layer && "content" in layer;
+}
+function isBaseLayer(layer) {
+  return "path" in layer;
+}
+
+// packages/config-mutations/src/mutations/config-mutation.ts
+function merge(options) {
+  return {
+    kind: "configMerge",
+    target: options.target,
+    value: options.value,
+    format: options.format,
+    pruneByPrefix: options.pruneByPrefix,
+    label: options.label
+  };
+}
+function prune(options) {
+  return {
+    kind: "configPrune",
+    target: options.target,
+    shape: options.shape,
+    format: options.format,
+    onlyIf: options.onlyIf,
+    label: options.label
+  };
+}
+function transform(options) {
+  return {
+    kind: "configTransform",
+    target: options.target,
+    format: options.format,
+    transform: options.transform,
+    label: options.label
+  };
+}
+var configMutation = {
+  merge,
+  prune,
+  transform
+};
+
+// packages/config-mutations/src/mutations/file-mutation.ts
+function ensureDirectory(options) {
+  return {
+    kind: "ensureDirectory",
+    path: options.path,
+    label: options.label
+  };
+}
+function remove(options) {
+  return {
+    kind: "removeFile",
+    target: options.target,
+    whenEmpty: options.whenEmpty,
+    whenContentMatches: options.whenContentMatches,
+    label: options.label
+  };
+}
+function removeDirectory(options) {
+  return {
+    kind: "removeDirectory",
+    path: options.path,
+    force: options.force,
+    label: options.label
+  };
+}
+function chmod(options) {
+  return {
+    kind: "chmod",
+    target: options.target,
+    mode: options.mode,
+    label: options.label
+  };
+}
+function backup(options) {
+  return {
+    kind: "backup",
+    target: options.target,
+    label: options.label
+  };
+}
+var fileMutation = {
+  ensureDirectory,
+  remove,
+  removeDirectory,
+  chmod,
+  backup
+};
+
+// packages/config-mutations/src/mutations/template-mutation.ts
+function write(options) {
+  return {
+    kind: "templateWrite",
+    target: options.target,
+    templateId: options.templateId,
+    context: options.context,
+    label: options.label
+  };
+}
+function mergeToml(options) {
+  return {
+    kind: "templateMergeToml",
+    target: options.target,
+    templateId: options.templateId,
+    context: options.context,
+    label: options.label
+  };
+}
+function mergeJson(options) {
+  return {
+    kind: "templateMergeJson",
+    target: options.target,
+    templateId: options.templateId,
+    context: options.context,
+    label: options.label
+  };
+}
+var templateMutation = {
+  write,
+  mergeToml,
+  mergeJson
+};
+
+// packages/config-mutations/src/execution/apply-mutation.ts
+import Mustache from "mustache";
+
+// packages/config-mutations/src/formats/json.ts
+import * as jsonc from "jsonc-parser";
+function isConfigObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parse2(content) {
+  if (!content || content.trim() === "") {
+    return {};
+  }
+  const errors = [];
+  const parsed = jsonc.parse(content, errors, {
+    allowTrailingComma: true,
+    disallowComments: false
+  });
+  if (errors.length > 0) {
+    throw new Error(`JSON parse error: ${jsonc.printParseErrorCode(errors[0].error)}`);
+  }
+  if (parsed === null || parsed === void 0) {
+    return {};
+  }
+  if (!isConfigObject(parsed)) {
+    throw new Error("Expected JSON object.");
+  }
+  return parsed;
+}
+function serialize(obj) {
+  return `${JSON.stringify(obj, null, 2)}
+`;
+}
+function merge2(base, patch) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) {
+      continue;
+    }
+    const existing = result[key];
+    if (isConfigObject(existing) && isConfigObject(value)) {
+      result[key] = merge2(existing, value);
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function prune2(obj, shape) {
+  let changed = false;
+  const result = { ...obj };
+  for (const [key, pattern] of Object.entries(shape)) {
+    if (!(key in result)) {
+      continue;
+    }
+    const current = result[key];
+    if (isConfigObject(pattern) && Object.keys(pattern).length === 0) {
+      delete result[key];
+      changed = true;
+      continue;
+    }
+    if (isConfigObject(pattern) && isConfigObject(current)) {
+      const { changed: childChanged, result: childResult } = prune2(
+        current,
+        pattern
+      );
+      if (childChanged) {
+        changed = true;
+      }
+      if (Object.keys(childResult).length === 0) {
+        delete result[key];
+      } else {
+        result[key] = childResult;
+      }
+      continue;
+    }
+    delete result[key];
+    changed = true;
+  }
+  return { changed, result };
+}
+var jsonFormat = {
+  parse: parse2,
+  serialize,
+  merge: merge2,
+  prune: prune2
+};
+
+// packages/config-mutations/src/formats/toml.ts
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+function isConfigObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parse3(content) {
+  if (!content || content.trim() === "") {
+    return {};
+  }
+  const parsed = parseToml(content);
+  if (!isConfigObject2(parsed)) {
+    throw new Error("Expected TOML document to be a table.");
+  }
+  return parsed;
+}
+function serialize2(obj) {
+  const serialized = stringifyToml(obj);
+  return serialized.endsWith("\n") ? serialized : `${serialized}
+`;
+}
+function merge3(base, patch) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) {
+      continue;
+    }
+    const existing = result[key];
+    if (isConfigObject2(existing) && isConfigObject2(value)) {
+      result[key] = merge3(existing, value);
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function prune3(obj, shape) {
+  let changed = false;
+  const result = { ...obj };
+  for (const [key, pattern] of Object.entries(shape)) {
+    if (!(key in result)) {
+      continue;
+    }
+    const current = result[key];
+    if (isConfigObject2(pattern) && Object.keys(pattern).length === 0) {
+      delete result[key];
+      changed = true;
+      continue;
+    }
+    if (isConfigObject2(pattern) && isConfigObject2(current)) {
+      const { changed: childChanged, result: childResult } = prune3(
+        current,
+        pattern
+      );
+      if (childChanged) {
+        changed = true;
+      }
+      if (Object.keys(childResult).length === 0) {
+        delete result[key];
+      } else {
+        result[key] = childResult;
+      }
+      continue;
+    }
+    delete result[key];
+    changed = true;
+  }
+  return { changed, result };
+}
+var tomlFormat = {
+  parse: parse3,
+  serialize: serialize2,
+  merge: merge3,
+  prune: prune3
+};
+
+// packages/config-mutations/src/formats/yaml.ts
+import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
+function isConfigObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parse4(content) {
+  if (!content || content.trim() === "") {
+    return {};
+  }
+  const parsed = parseYaml2(content);
+  if (parsed === null || parsed === void 0) {
+    return {};
+  }
+  if (!isConfigObject3(parsed)) {
+    throw new Error("Expected YAML object.");
+  }
+  return parsed;
+}
+function serialize3(obj) {
+  const serialized = stringifyYaml(obj);
+  return serialized.endsWith("\n") ? serialized : `${serialized}
+`;
+}
+function merge4(base, patch) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) {
+      continue;
+    }
+    const existing = result[key];
+    if (isConfigObject3(existing) && isConfigObject3(value)) {
+      result[key] = merge4(existing, value);
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function prune4(obj, shape) {
+  let changed = false;
+  const result = { ...obj };
+  for (const [key, pattern] of Object.entries(shape)) {
+    if (!(key in result)) {
+      continue;
+    }
+    const current = result[key];
+    if (isConfigObject3(pattern) && Object.keys(pattern).length === 0) {
+      delete result[key];
+      changed = true;
+      continue;
+    }
+    if (isConfigObject3(pattern) && isConfigObject3(current)) {
+      const { changed: childChanged, result: childResult } = prune4(current, pattern);
+      if (childChanged) {
+        changed = true;
+      }
+      if (Object.keys(childResult).length === 0) {
+        delete result[key];
+      } else {
+        result[key] = childResult;
+      }
+      continue;
+    }
+    delete result[key];
+    changed = true;
+  }
+  return { changed, result };
+}
+var yamlFormat = {
+  parse: parse4,
+  serialize: serialize3,
+  merge: merge4,
+  prune: prune4
+};
+
+// packages/config-mutations/src/formats/index.ts
+var formatRegistry = {
+  json: jsonFormat,
+  toml: tomlFormat,
+  yaml: yamlFormat
+};
+var extensionMap = {
+  ".json": "json",
+  ".toml": "toml",
+  ".yaml": "yaml",
+  ".yml": "yaml"
+};
+function getConfigFormat(pathOrFormat) {
+  if (pathOrFormat in formatRegistry) {
+    return formatRegistry[pathOrFormat];
+  }
+  const ext = getExtension(pathOrFormat);
+  const formatName = extensionMap[ext];
+  if (!formatName) {
+    throw new Error(
+      `Unsupported config format. Cannot detect format from "${pathOrFormat}". Supported extensions: ${Object.keys(extensionMap).join(", ")}. Supported format names: ${Object.keys(formatRegistry).join(", ")}.`
+    );
+  }
+  return formatRegistry[formatName];
+}
+function detectFormat2(path25) {
+  const ext = getExtension(path25);
+  return extensionMap[ext];
+}
+function getExtension(path25) {
+  const lastDot = path25.lastIndexOf(".");
+  if (lastDot === -1) {
+    return "";
+  }
+  return path25.slice(lastDot).toLowerCase();
+}
+
+// packages/config-mutations/src/execution/path-utils.ts
+import path5 from "node:path";
+function expandHome(targetPath, homeDir) {
+  if (!targetPath?.startsWith("~")) {
+    return targetPath;
+  }
+  if (targetPath.startsWith("~./")) {
+    targetPath = `~/.${targetPath.slice(3)}`;
+  }
+  let remainder = targetPath.slice(1);
+  if (remainder.startsWith("/") || remainder.startsWith("\\")) {
+    remainder = remainder.slice(1);
+  } else if (remainder.startsWith(".")) {
+    remainder = remainder.slice(1);
+    if (remainder.startsWith("/") || remainder.startsWith("\\")) {
+      remainder = remainder.slice(1);
+    }
+  }
+  return remainder.length === 0 ? homeDir : path5.join(homeDir, remainder);
+}
+function validateHomePath(targetPath) {
+  if (typeof targetPath !== "string" || targetPath.length === 0) {
+    throw new Error("Target path must be a non-empty string.");
+  }
+  if (!targetPath.startsWith("~")) {
+    throw new Error(
+      `All target paths must be home-relative (start with ~). Received: "${targetPath}"`
+    );
+  }
+}
+function resolvePath(rawPath, homeDir, pathMapper) {
+  validateHomePath(rawPath);
+  const expanded = expandHome(rawPath, homeDir);
+  if (!pathMapper) {
+    return expanded;
+  }
+  const rawDirectory = path5.dirname(expanded);
+  const mappedDirectory = pathMapper.mapTargetDirectory({
+    targetDirectory: rawDirectory
+  });
+  const filename = path5.basename(expanded);
+  return filename.length === 0 ? mappedDirectory : path5.join(mappedDirectory, filename);
+}
+
+// packages/config-mutations/src/fs-utils.ts
+function isNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function readFileIfExists(fs13, target) {
+  try {
+    return await fs13.readFile(target, "utf8");
+  } catch (error) {
+    if (isNotFound(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function pathExists(fs13, target) {
+  try {
+    await fs13.stat(target);
+    return true;
+  } catch (error) {
+    if (isNotFound(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+function createTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-").replaceAll(".", "-");
+}
+
+// packages/config-mutations/src/execution/apply-mutation.ts
+function resolveValue(resolver, options) {
+  if (typeof resolver === "function") {
+    return resolver(options);
+  }
+  return resolver;
+}
+function createInvalidDocumentBackupPath(targetPath) {
+  const ext = targetPath.includes(".") ? targetPath.split(".").pop() : "bak";
+  return `${targetPath}.invalid-${createTimestamp()}.${ext}`;
+}
+async function backupInvalidDocument(fs13, targetPath, content) {
+  const backupPath = createInvalidDocumentBackupPath(targetPath);
+  await fs13.writeFile(backupPath, content, { encoding: "utf8" });
+}
+function describeMutation(kind, targetPath) {
+  const displayPath = targetPath ?? "target";
+  switch (kind) {
+    case "ensureDirectory":
+      return `Create ${displayPath}`;
+    case "removeDirectory":
+      return `Remove directory ${displayPath}`;
+    case "backup":
+      return `Backup ${displayPath}`;
+    case "templateWrite":
+      return `Write ${displayPath}`;
+    case "chmod":
+      return `Set permissions on ${displayPath}`;
+    case "removeFile":
+      return `Remove ${displayPath}`;
+    case "configMerge":
+    case "configPrune":
+    case "configTransform":
+    case "templateMergeToml":
+    case "templateMergeJson":
+      return `Update ${displayPath}`;
+    default:
+      return "Operation";
+  }
+}
+function pruneKeysByPrefix(table, prefix) {
+  const result = {};
+  for (const [key, value] of Object.entries(table)) {
+    if (!key.startsWith(prefix)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function isConfigObject4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeWithPruneByPrefix(base, patch, pruneByPrefix) {
+  const result = { ...base };
+  const prefixMap = pruneByPrefix ?? {};
+  for (const [key, value] of Object.entries(patch)) {
+    const current = result[key];
+    const prefix = prefixMap[key];
+    if (isConfigObject4(current) && isConfigObject4(value)) {
+      if (prefix) {
+        const pruned = pruneKeysByPrefix(current, prefix);
+        result[key] = { ...pruned, ...value };
+      } else {
+        result[key] = mergeWithPruneByPrefix(
+          current,
+          value,
+          prefixMap
+        );
+      }
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+async function applyMutation(mutation, context, options) {
+  switch (mutation.kind) {
+    case "ensureDirectory":
+      return applyEnsureDirectory(mutation, context, options);
+    case "removeDirectory":
+      return applyRemoveDirectory(mutation, context, options);
+    case "removeFile":
+      return applyRemoveFile(mutation, context, options);
+    case "chmod":
+      return applyChmod(mutation, context, options);
+    case "backup":
+      return applyBackup(mutation, context, options);
+    case "configMerge":
+      return applyConfigMerge(mutation, context, options);
+    case "configPrune":
+      return applyConfigPrune(mutation, context, options);
+    case "configTransform":
+      return applyConfigTransform(mutation, context, options);
+    case "templateWrite":
+      return applyTemplateWrite(mutation, context, options);
+    case "templateMergeToml":
+      return applyTemplateMerge(mutation, context, options, "toml");
+    case "templateMergeJson":
+      return applyTemplateMerge(mutation, context, options, "json");
+    default: {
+      const never = mutation;
+      throw new Error(`Unknown mutation kind: ${never.kind}`);
+    }
+  }
+}
+async function applyEnsureDirectory(mutation, context, options) {
+  const rawPath = resolveValue(mutation.path, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const existed = await pathExists(context.fs, targetPath);
+  if (!context.dryRun) {
+    await context.fs.mkdir(targetPath, { recursive: true });
+  }
+  return {
+    outcome: {
+      changed: !existed,
+      effect: "mkdir",
+      detail: existed ? "noop" : "create"
+    },
+    details
+  };
+}
+async function applyRemoveDirectory(mutation, context, options) {
+  const rawPath = resolveValue(mutation.path, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const existed = await pathExists(context.fs, targetPath);
+  if (!existed) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (typeof context.fs.rm !== "function") {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (mutation.force) {
+    if (!context.dryRun) {
+      await context.fs.rm(targetPath, { recursive: true, force: true });
+    }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  }
+  const entries = await context.fs.readdir(targetPath);
+  if (entries.length > 0) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (!context.dryRun) {
+    await context.fs.rm(targetPath, { recursive: true, force: true });
+  }
+  return {
+    outcome: { changed: true, effect: "delete", detail: "delete" },
+    details
+  };
+}
+async function applyRemoveFile(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  try {
+    const content = await context.fs.readFile(targetPath, "utf8");
+    const trimmed = content.trim();
+    if (mutation.whenContentMatches && !mutation.whenContentMatches.test(trimmed)) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (mutation.whenEmpty && trimmed.length > 0) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (!context.dryRun) {
+      await context.fs.unlink(targetPath);
+    }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  } catch (error) {
+    if (isNotFound(error)) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    throw error;
+  }
+}
+async function applyChmod(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  if (typeof context.fs.chmod !== "function") {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  try {
+    const stat6 = await context.fs.stat(targetPath);
+    const currentMode = typeof stat6.mode === "number" ? stat6.mode & 511 : null;
+    if (currentMode === mutation.mode) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (!context.dryRun) {
+      await context.fs.chmod(targetPath, mutation.mode);
+    }
+    return {
+      outcome: { changed: true, effect: "chmod", detail: "update" },
+      details
+    };
+  } catch (error) {
+    if (isNotFound(error)) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    throw error;
+  }
+}
+async function applyBackup(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const content = await readFileIfExists(context.fs, targetPath);
+  if (content === null) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (!context.dryRun) {
+    const backupPath = `${targetPath}.backup-${createTimestamp()}`;
+    await context.fs.writeFile(backupPath, content, { encoding: "utf8" });
+  }
+  return {
+    outcome: { changed: true, effect: "copy", detail: "backup" },
+    details
+  };
+}
+async function applyConfigMerge(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const formatName = mutation.format ?? detectFormat2(rawPath);
+  if (!formatName) {
+    throw new Error(
+      `Cannot detect config format for "${rawPath}". Provide explicit format option.`
+    );
+  }
+  const format = getConfigFormat(formatName);
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  let current;
+  try {
+    current = rawContent === null ? {} : format.parse(rawContent);
+  } catch {
+    if (rawContent !== null) {
+      await backupInvalidDocument(context.fs, targetPath, rawContent);
+    }
+    current = {};
+  }
+  const value = resolveValue(mutation.value, options);
+  let merged;
+  if (mutation.pruneByPrefix) {
+    merged = mergeWithPruneByPrefix(current, value, mutation.pruneByPrefix);
+  } else {
+    merged = format.merge(current, value);
+  }
+  const serialized = format.serialize(merged);
+  const changed = serialized !== rawContent;
+  if (changed && !context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed,
+      effect: changed ? "write" : "none",
+      detail: changed ? rawContent === null ? "create" : "update" : "noop"
+    },
+    details
+  };
+}
+async function applyConfigPrune(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  if (rawContent === null) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  const formatName = mutation.format ?? detectFormat2(rawPath);
+  if (!formatName) {
+    throw new Error(
+      `Cannot detect config format for "${rawPath}". Provide explicit format option.`
+    );
+  }
+  const format = getConfigFormat(formatName);
+  let current;
+  try {
+    current = format.parse(rawContent);
+  } catch {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (mutation.onlyIf && !mutation.onlyIf(current, options)) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  const shape = resolveValue(mutation.shape, options);
+  const { changed, result } = format.prune(current, shape);
+  if (!changed) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (Object.keys(result).length === 0) {
+    if (!context.dryRun) {
+      await context.fs.unlink(targetPath);
+    }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  }
+  const serialized = format.serialize(result);
+  if (!context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: { changed: true, effect: "write", detail: "update" },
+    details
+  };
+}
+async function applyConfigTransform(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const formatName = mutation.format ?? detectFormat2(rawPath);
+  if (!formatName) {
+    throw new Error(
+      `Cannot detect config format for "${rawPath}". Provide explicit format option.`
+    );
+  }
+  const format = getConfigFormat(formatName);
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  let current;
+  try {
+    current = rawContent === null ? {} : format.parse(rawContent);
+  } catch {
+    if (rawContent !== null) {
+      await backupInvalidDocument(context.fs, targetPath, rawContent);
+    }
+    current = {};
+  }
+  const { content: transformed, changed } = mutation.transform(current, options);
+  if (!changed) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (transformed === null) {
+    if (rawContent === null) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (!context.dryRun) {
+      await context.fs.unlink(targetPath);
+    }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  }
+  const serialized = format.serialize(transformed);
+  if (!context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed: true,
+      effect: "write",
+      detail: rawContent === null ? "create" : "update"
+    },
+    details
+  };
+}
+async function applyTemplateWrite(mutation, context, options) {
+  if (!context.templates) {
+    throw new Error(
+      "Template mutations require a templates loader. Provide templates function to runMutations context."
+    );
+  }
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const template = await context.templates(mutation.templateId);
+  const templateContext = mutation.context ? resolveValue(mutation.context, options) : {};
+  const rendered = Mustache.render(template, templateContext);
+  const existed = await pathExists(context.fs, targetPath);
+  if (!context.dryRun) {
+    await context.fs.writeFile(targetPath, rendered, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed: true,
+      effect: "write",
+      detail: existed ? "update" : "create"
+    },
+    details
+  };
+}
+async function applyTemplateMerge(mutation, context, options, formatName) {
+  if (!context.templates) {
+    throw new Error(
+      "Template mutations require a templates loader. Provide templates function to runMutations context."
+    );
+  }
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const format = getConfigFormat(formatName);
+  const template = await context.templates(mutation.templateId);
+  const templateContext = mutation.context ? resolveValue(mutation.context, options) : {};
+  const rendered = Mustache.render(template, templateContext);
+  let templateDoc;
+  try {
+    templateDoc = format.parse(rendered);
+  } catch (error) {
+    throw new Error(
+      `Failed to parse rendered template "${mutation.templateId}" as ${formatName.toUpperCase()}: ${error}`,
+      { cause: error }
+    );
+  }
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  let current;
+  try {
+    current = rawContent === null ? {} : format.parse(rawContent);
+  } catch {
+    if (rawContent !== null) {
+      await backupInvalidDocument(context.fs, targetPath, rawContent);
+    }
+    current = {};
+  }
+  const merged = format.merge(current, templateDoc);
+  const serialized = format.serialize(merged);
+  const changed = serialized !== rawContent;
+  if (changed && !context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed,
+      effect: changed ? "write" : "none",
+      detail: changed ? rawContent === null ? "create" : "update" : "noop"
+    },
+    details
+  };
+}
+
+// packages/config-mutations/src/execution/run-mutations.ts
+async function runMutations(mutations, context, options) {
+  const effects = [];
+  let anyChanged = false;
+  const resolverOptions = options ?? {};
+  for (const mutation of mutations) {
+    const { outcome } = await executeMutation(
+      mutation,
+      context,
+      resolverOptions
+    );
+    effects.push(outcome);
+    if (outcome.changed) {
+      anyChanged = true;
+    }
+  }
+  return {
+    changed: anyChanged,
+    effects
+  };
+}
+async function executeMutation(mutation, context, options) {
+  context.observers?.onStart?.({
+    kind: mutation.kind,
+    label: mutation.label ?? mutation.kind,
+    targetPath: void 0
+    // Will be resolved during apply
+  });
+  try {
+    const { outcome, details } = await applyMutation(mutation, context, options);
+    context.observers?.onComplete?.(details, outcome);
+    return { outcome, details };
+  } catch (error) {
+    context.observers?.onError?.(
+      {
+        kind: mutation.kind,
+        label: mutation.label ?? mutation.kind,
+        targetPath: void 0
+      },
+      error
+    );
+    throw error;
+  }
+}
+
+// packages/config-mutations/src/template/render.ts
+import Mustache2 from "mustache";
+var originalEscape = Mustache2.escape;
+
+// packages/poe-code-config/src/store.ts
+async function readMergedDocument(fs13, globalPath, projectPath) {
+  const globalDocument = await readStoredDocument(fs13, globalPath);
+  if (!projectPath) {
+    return globalDocument.data;
+  }
+  const projectDocument = await readStoredDocument(fs13, projectPath);
+  const resolved = await resolve(
+    [
+      {
+        source: "project",
+        filePath: projectPath,
+        content: projectDocument.content
+      },
+      {
+        source: "base",
+        path: path6.dirname(globalPath)
+      }
+    ],
+    {
+      fs: createResolvedConfigFs(fs13, globalPath, globalDocument.content),
+      autoExtend: true
+    }
+  );
+  return normalizeDocument(resolved.data);
+}
+async function readStoredDocument(fs13, filePath) {
+  try {
+    const raw = await fs13.readFile(filePath, "utf8");
+    return await parseStoredDocument(fs13, filePath, raw);
+  } catch (error) {
+    if (isNotFound(error)) {
+      return {
+        content: EMPTY_DOCUMENT,
+        data: {}
+      };
+    }
+    throw error;
+  }
+}
+async function parseStoredDocument(fs13, filePath, raw) {
+  try {
+    return {
+      content: raw,
+      data: normalizeDocument(JSON.parse(raw))
+    };
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      await recoverInvalidDocument(fs13, filePath, raw);
+      return {
+        content: EMPTY_DOCUMENT,
+        data: {}
+      };
+    }
+    throw error;
+  }
+}
+function normalizeDocument(value) {
+  if (!isRecord(value)) {
+    return {};
+  }
+  const document = {};
+  for (const [scope, scopeValues] of Object.entries(value)) {
+    const normalizedValues = normalizeScopeValues(scopeValues);
+    if (Object.keys(normalizedValues).length > 0) {
+      document[scope] = normalizedValues;
+    }
+  }
+  return document;
+}
+function normalizeScopeValues(value) {
+  if (!isRecord(value)) {
+    return {};
+  }
+  const normalized = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (entry !== void 0) {
+      normalized[key] = entry;
+    }
+  }
+  return normalized;
+}
+function createResolvedConfigFs(fs13, globalPath, globalContent) {
+  return {
+    readFile(filePath, _encoding) {
+      if (filePath === globalPath) {
+        return Promise.resolve(globalContent);
+      }
+      return fs13.readFile(filePath, "utf8");
+    }
+  };
+}
+async function recoverInvalidDocument(fs13, filePath, content) {
+  await fs13.mkdir(path6.dirname(filePath), { recursive: true });
+  const backupPath = createInvalidBackupPath(filePath);
+  await fs13.writeFile(backupPath, content, { encoding: "utf8" });
+  await fs13.writeFile(filePath, EMPTY_DOCUMENT, { encoding: "utf8" });
+}
+function createInvalidBackupPath(filePath) {
+  const directory = path6.dirname(filePath);
+  const baseName = path6.basename(filePath);
+  return path6.join(directory, `${baseName}.invalid-${createTimestamp()}.json`);
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+var EMPTY_DOCUMENT = `${JSON.stringify({}, null, 2)}
+`;
+
+// packages/poe-code-config/src/memory.ts
+async function configuredMemoryRoot(options) {
+  return (await resolveMemoryConfig(options)).root;
+}
+async function resolveAgent(options, fallbackAgent) {
+  const memory = await resolveMemoryConfig(options);
+  return memory.ingestAgent ?? fallbackAgent;
+}
+async function configuredTimeout(options) {
+  return (await resolveMemoryConfig(options)).ingestTimeoutMs;
+}
+async function cacheEnabled(options) {
+  return (await resolveMemoryConfig(options)).cacheEnabled;
+}
+async function resolveMemoryConfig(options) {
+  const document = await readMergedDocument(options.fs, options.filePath, options.projectFilePath);
+  const memory = asRecord(document.memory);
+  const cache = asRecord(memory?.cache);
+  const mcp = asRecord(memory?.mcp);
+  const query = asRecord(memory?.query);
+  return {
+    root: readString(memory?.root),
+    ingestAgent: readString(memory?.ingestAgent),
+    ingestTimeoutMs: readNumber(memory?.ingestTimeoutMs) ?? 3e5,
+    cacheEnabled: readBoolean(cache?.enabled) ?? true,
+    mcpWritesAllowed: readBoolean(mcp?.allowWrites) ?? false,
+    defaultQueryBudget: readNumber(query?.defaultBudgetTokens) ?? 4096
+  };
+}
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  return value;
+}
+function readString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function readNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+
+// packages/poe-code-config/src/inspect.ts
+import path7 from "node:path";
+var EMPTY_DOCUMENT2 = `${JSON.stringify({}, null, 2)}
+`;
+
+// packages/memory/src/resolve-root.ts
+var MEMORY_ROOT_ENV_VAR = "POE_CODE_MEMORY_ROOT";
+async function resolveConfiguredMemoryRoot(options) {
+  const envOverride = options.env[MEMORY_ROOT_ENV_VAR]?.trim();
+  if (envOverride && envOverride.length > 0) {
+    return resolveAgainstCwd(options.cwd, envOverride);
+  }
+  const configOverride = (await configuredMemoryRoot({
+    fs: options.fs,
+    filePath: options.configPath,
+    projectFilePath: options.projectConfigPath
+  }))?.trim();
+  if (configOverride && configOverride.length > 0) {
+    return resolveAgainstCwd(options.cwd, configOverride);
+  }
+  return resolveMemoryRoot(options.cwd);
+}
+function resolveAgainstCwd(cwd, value) {
+  return path8.isAbsolute(value) ? value : path8.resolve(cwd, value);
+}
+
+// packages/memory/src/init.ts
+import * as fs from "node:fs/promises";
+import path9 from "node:path";
+async function initMemory(root) {
+  await fs.mkdir(path9.join(root, MEMORY_PAGES_DIR_RELPATH), { recursive: true });
+  await writeFileIfMissing(path9.join(root, MEMORY_INDEX_RELPATH), "# Memory index\n");
+  await writeFileIfMissing(path9.join(root, MEMORY_LOG_RELPATH), "");
+}
+async function writeFileIfMissing(filePath, content) {
+  try {
+    await fs.writeFile(filePath, content, { encoding: "utf8", flag: "wx" });
+  } catch (error) {
+    if (!hasErrorCode(error, "EEXIST")) {
+      throw error;
+    }
+  }
+}
+function hasErrorCode(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+
+// packages/memory/src/pages.ts
+import * as fs2 from "node:fs/promises";
+import path10 from "node:path";
+
+// packages/memory/src/frontmatter.ts
+import { parse as parse5, stringify } from "yaml";
+function parseFrontmatter(markdown) {
+  const content = markdown.startsWith("\uFEFF") ? markdown.slice(1) : markdown;
+  const openingLineBreak = readOpeningLineBreak(content);
+  if (openingLineBreak === void 0) {
+    return {
+      frontmatter: {},
+      body: markdown
+    };
+  }
+  const frontmatterStart = 3 + openingLineBreak.length;
+  const closingFenceIndex = findClosingFence(content, frontmatterStart);
+  const yamlBlock = content.slice(frontmatterStart, closingFenceIndex);
+  const bodyStart = closingFenceIndex + 4;
+  return {
+    frontmatter: parsePageFrontmatter(parseYamlFrontmatter(yamlBlock)),
+    body: readBody(content, bodyStart)
+  };
+}
+function serializeFrontmatter(frontmatter, body) {
+  const serialized = {
+    ...frontmatter.name === void 0 ? {} : { name: frontmatter.name },
+    ...frontmatter.description === void 0 ? {} : { description: frontmatter.description },
+    ...frontmatter.lastTouchedAt === void 0 ? {} : { last_touched_at: frontmatter.lastTouchedAt },
+    ...frontmatter.sources === void 0 || frontmatter.sources.length === 0 ? {} : { sources: frontmatter.sources.map((source) => serializeSourceRef(source)) }
+  };
+  if (Object.keys(serialized).length === 0) {
+    return body;
+  }
+  return `---
+${stringify(serialized).trimEnd()}
+---
+${body}`;
+}
+function parseSourceRef(serialized) {
+  const [rawPath, rawAnchor] = serialized.split("#", 2);
+  const normalizedPath = rawPath?.trim();
+  if (normalizedPath === void 0 || normalizedPath.length === 0) {
+    throw new Error(`Invalid source ref "${serialized}".`);
+  }
+  if (rawAnchor === void 0) {
+    return { path: normalizedPath };
+  }
+  const singleLineMatch = /^L(\d+)$/.exec(rawAnchor);
+  if (singleLineMatch !== null) {
+    const startLine = Number.parseInt(singleLineMatch[1], 10);
+    assertValidLineNumber(startLine, serialized);
+    return {
+      path: normalizedPath,
+      startLine
+    };
+  }
+  const rangeMatch = /^L(\d+)-L?(\d+)$/.exec(rawAnchor);
+  if (rangeMatch !== null) {
+    const startLine = Number.parseInt(rangeMatch[1], 10);
+    const endLine = Number.parseInt(rangeMatch[2], 10);
+    assertValidLineNumber(startLine, serialized);
+    assertValidLineNumber(endLine, serialized);
+    if (endLine < startLine) {
+      throw new Error(`Invalid source ref "${serialized}": line range is reversed.`);
+    }
+    return {
+      path: normalizedPath,
+      startLine,
+      endLine
+    };
+  }
+  throw new Error(`Invalid source ref "${serialized}".`);
+}
+function serializeSourceRef(source) {
+  if (source.path.trim().length === 0) {
+    throw new Error("Source path cannot be empty.");
+  }
+  if (source.startLine === void 0) {
+    if (source.endLine !== void 0) {
+      throw new Error("Source endLine requires startLine.");
+    }
+    return source.path;
+  }
+  assertValidLineNumber(source.startLine, source.path);
+  if (source.endLine === void 0) {
+    return `${source.path}#L${source.startLine}`;
+  }
+  assertValidLineNumber(source.endLine, source.path);
+  if (source.endLine < source.startLine) {
+    throw new Error(`Invalid source ref "${source.path}": line range is reversed.`);
+  }
+  return `${source.path}#L${source.startLine}-L${source.endLine}`;
+}
+function readOpeningLineBreak(markdown) {
+  if (!markdown.startsWith("---")) {
+    return void 0;
+  }
+  const nextCharacter = markdown[3];
+  if (nextCharacter === "\n") {
+    return "\n";
+  }
+  if (nextCharacter === "\r" && markdown[4] === "\n") {
+    return "\r\n";
+  }
+  return nextCharacter === void 0 ? "\n" : void 0;
+}
+function findClosingFence(markdown, searchFrom) {
+  let currentIndex = searchFrom - 1;
+  while (currentIndex < markdown.length) {
+    const candidateIndex = markdown.indexOf("\n---", currentIndex);
+    if (candidateIndex === -1) {
+      throw new Error("Missing YAML frontmatter end delimiter (---).");
+    }
+    const fenceEnd = candidateIndex + 4;
+    const nextCharacter = markdown[fenceEnd];
+    if (nextCharacter === "\n" || nextCharacter === void 0) {
+      return candidateIndex;
+    }
+    if (nextCharacter === "\r" && markdown[fenceEnd + 1] === "\n") {
+      return candidateIndex;
+    }
+    currentIndex = fenceEnd;
+  }
+  throw new Error("Missing YAML frontmatter end delimiter (---).");
+}
+function readBody(markdown, bodyStart) {
+  const nextCharacter = markdown[bodyStart];
+  if (nextCharacter === "\n") {
+    return markdown.slice(bodyStart + 1);
+  }
+  if (nextCharacter === "\r" && markdown[bodyStart + 1] === "\n") {
+    return markdown.slice(bodyStart + 2);
+  }
+  return markdown.slice(bodyStart);
+}
+function parseYamlFrontmatter(yamlBlock) {
+  const normalizedYamlBlock = yamlBlock.includes("\r") ? yamlBlock.replaceAll("\r\n", "\n").replaceAll("\r", "") : yamlBlock;
+  let parsed;
+  try {
+    parsed = parse5(normalizedYamlBlock);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown YAML parse error";
+    throw new Error(`Invalid YAML frontmatter: ${message}`);
+  }
+  if (parsed === null) {
+    return {};
+  }
+  if (!isRecord2(parsed)) {
+    throw new Error("YAML frontmatter must parse to an object.");
+  }
+  return parsed;
+}
+function parsePageFrontmatter(value) {
+  const name = readOptionalString(value.name, "name");
+  const description = readOptionalString(value.description, "description");
+  const lastTouchedAt = readOptionalString(
+    value.last_touched_at ?? value.lastTouchedAt,
+    "last_touched_at"
+  );
+  const sources = parseSources(value.sources);
+  return {
+    ...name === void 0 ? {} : { name },
+    ...description === void 0 ? {} : { description },
+    ...lastTouchedAt === void 0 ? {} : { lastTouchedAt },
+    ...sources === void 0 ? {} : { sources }
+  };
+}
+function parseSources(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    throw new Error('Invalid "sources" frontmatter. Expected an array.');
+  }
+  return value.map((item) => {
+    if (typeof item === "string") {
+      return parseSourceRef(item);
+    }
+    if (!isRecord2(item)) {
+      throw new Error('Invalid "sources" frontmatter. Expected each source to be a string or object.');
+    }
+    const path25 = readRequiredString(item.path, "sources[].path");
+    const startLine = readOptionalPositiveInteger(item.startLine, "sources[].startLine");
+    const endLine = readOptionalPositiveInteger(item.endLine, "sources[].endLine");
+    return parseSourceRef(serializeSourceRef({ path: path25, ...startLine === void 0 ? {} : { startLine }, ...endLine === void 0 ? {} : { endLine } }));
+  });
+}
+function readOptionalString(value, field) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`Invalid "${field}" frontmatter. Expected a string.`);
+  }
+  return value;
+}
+function readRequiredString(value, field) {
+  const parsed = readOptionalString(value, field);
+  if (parsed === void 0) {
+    throw new Error(`Invalid "${field}" frontmatter. Expected a string.`);
+  }
+  return parsed;
+}
+function readOptionalPositiveInteger(value, field) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    throw new Error(`Invalid "${field}" frontmatter. Expected a positive integer.`);
+  }
+  return value;
+}
+function assertValidLineNumber(line, value) {
+  if (!Number.isInteger(line) || line <= 0) {
+    throw new Error(`Invalid source ref "${value}": line numbers must be positive integers.`);
+  }
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// packages/memory/src/pages.ts
+async function listPages(root) {
+  const relPaths = await collectMarkdownRelPaths(root, MEMORY_PAGES_DIR_RELPATH);
+  const pages = await Promise.all(relPaths.map(async (relPath) => readPage(root, relPath)));
+  return pages.sort((left, right) => left.relPath.localeCompare(right.relPath));
+}
+async function readPage(root, relPath) {
+  const normalizedRelPath = assertMarkdownRelPath(relPath);
+  const absPath = path10.join(root, normalizedRelPath);
+  const [content, stat6] = await Promise.all([fs2.readFile(absPath, "utf8"), fs2.stat(absPath)]);
+  try {
+    const parsed = parseFrontmatter(content);
+    return {
+      relPath: normalizedRelPath,
+      frontmatter: parsed.frontmatter,
+      body: parsed.body,
+      bytes: Buffer.byteLength(content),
+      mtimeMs: stat6.mtimeMs
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Failed to parse frontmatter for "${normalizedRelPath}": ${message}`);
+    return {
+      relPath: normalizedRelPath,
+      frontmatter: {},
+      body: content,
+      bytes: Buffer.byteLength(content),
+      mtimeMs: stat6.mtimeMs
+    };
+  }
+}
+async function collectMarkdownRelPaths(root, startRelPath = "") {
+  const relPaths = [];
+  await collectMarkdownRelPathsInto(root, startRelPath, relPaths);
+  return relPaths.sort((left, right) => left.localeCompare(right));
+}
+async function collectMarkdownRelPathsInto(root, currentRelPath, relPaths) {
+  const absPath = path10.join(root, currentRelPath);
+  let entryNames;
+  try {
+    entryNames = await fs2.readdir(absPath);
+  } catch (error) {
+    if (isMissing(error)) {
+      return;
+    }
+    throw error;
+  }
+  for (const entryName of entryNames.sort((left, right) => left.localeCompare(right))) {
+    const entryRelPath = currentRelPath.length === 0 ? entryName : path10.posix.join(currentRelPath, entryName);
+    const entryAbsPath = path10.join(root, entryRelPath);
+    const entryStat = await fs2.stat(entryAbsPath);
+    if (entryStat.isDirectory()) {
+      if (entryName === MEMORY_CACHE_DIR_RELPATH) {
+        continue;
+      }
+      await collectMarkdownRelPathsInto(root, entryRelPath, relPaths);
+      continue;
+    }
+    if (!entryStat.isFile()) {
+      continue;
+    }
+    if (!isMarkdownPath(entryRelPath)) {
+      if (entryName === MEMORY_LOCK_RELPATH) {
+        continue;
+      }
+      console.warn(`Skipping non-markdown memory file "${entryRelPath}".`);
+      continue;
+    }
+    relPaths.push(entryRelPath);
+  }
+}
+function assertMarkdownRelPath(relPath) {
+  const normalizedRelPath = assertSafeRelPath(relPath);
+  if (!isMarkdownPath(normalizedRelPath)) {
+    throw new Error(`Expected a markdown path, received "${relPath}".`);
+  }
+  return normalizedRelPath;
+}
+function isMarkdownPath(relPath) {
+  return path10.posix.extname(relPath).toLowerCase() === ".md";
+}
+function isMissing(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// packages/memory/src/search.ts
+import * as fs3 from "node:fs/promises";
+import path11 from "node:path";
+async function searchMemory(root, query) {
+  const normalizedQuery = query.trim();
+  if (normalizedQuery.length === 0) {
+    throw new Error("Search query cannot be empty.");
+  }
+  const relPaths = await collectMarkdownRelPaths(root);
+  const hits = [];
+  for (const relPath of relPaths) {
+    const content = await fs3.readFile(path11.join(root, relPath), "utf8");
+    if (content.length === 0) {
+      continue;
+    }
+    const lines = content.replaceAll("\r\n", "\n").split("\n");
+    for (const [index, line] of lines.entries()) {
+      if (!line.includes(normalizedQuery)) {
+        continue;
+      }
+      hits.push({
+        relPath,
+        lineNumber: index + 1,
+        line
+      });
+    }
+  }
+  return hits;
+}
+
+// packages/memory/src/status.ts
+import * as fs4 from "node:fs/promises";
+import path12 from "node:path";
+async function statusOf(root) {
+  if (!await pathExists2(root)) {
+    return {
+      pageCount: 0,
+      totalBytes: 0,
+      lastWriteAt: null,
+      initialized: false
+    };
+  }
+  const [pageRelPaths, markdownRelPaths] = await Promise.all([
+    collectMarkdownRelPaths(root, MEMORY_PAGES_DIR_RELPATH),
+    collectMarkdownRelPaths(root)
+  ]);
+  let totalBytes = 0;
+  let lastWriteAtMs = Number.NEGATIVE_INFINITY;
+  for (const relPath of markdownRelPaths) {
+    const stat6 = await fs4.stat(path12.join(root, relPath));
+    totalBytes += stat6.size;
+    lastWriteAtMs = Math.max(lastWriteAtMs, stat6.mtimeMs);
+  }
+  return {
+    pageCount: pageRelPaths.length,
+    totalBytes,
+    lastWriteAt: Number.isFinite(lastWriteAtMs) ? new Date(lastWriteAtMs).toISOString() : null,
+    initialized: true
+  };
+}
+async function pathExists2(targetPath) {
+  try {
+    await fs4.stat(targetPath);
+    return true;
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+
+// packages/memory/src/edit.ts
+import * as fs7 from "node:fs/promises";
+import path16 from "node:path";
+
+// packages/memory/src/write.ts
+import * as fs6 from "node:fs/promises";
+import path15 from "node:path";
+
+// packages/memory/src/lock.ts
+import * as fsPromises from "node:fs/promises";
+import path13 from "node:path";
+function createDefaultFs() {
+  return {
+    readFile: (filePath, encoding) => fsPromises.readFile(filePath, encoding),
+    unlink: fsPromises.unlink,
+    writeFile: (filePath, data, options) => fsPromises.writeFile(filePath, data, options)
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function hasErrorCode2(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+function lockDelay(attempt, minTimeoutMs, maxTimeoutMs) {
+  return Math.min(maxTimeoutMs, minTimeoutMs * Math.pow(2, attempt));
+}
+function parsePid(input) {
+  const value = input.trim();
+  if (value.length === 0) {
+    return void 0;
+  }
+  for (const char of value) {
+    if (char < "0" || char > "9") {
+      return void 0;
+    }
+  }
+  const pid = Number.parseInt(value, 10);
+  return Number.isSafeInteger(pid) && pid > 0 ? pid : void 0;
+}
+function isPidRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return !hasErrorCode2(error, "ESRCH");
+  }
+}
+async function removeLockFile(fs13, lockPath) {
+  try {
+    await fs13.unlink(lockPath);
+  } catch (error) {
+    if (!hasErrorCode2(error, "ENOENT")) {
+      throw error;
+    }
+  }
+}
+async function readLockPid(fs13, lockPath) {
+  try {
+    return parsePid(await fs13.readFile(lockPath, "utf8"));
+  } catch (error) {
+    if (hasErrorCode2(error, "ENOENT")) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function withLock(root, run, options = {}) {
+  const fs13 = options.fs ?? createDefaultFs();
+  const lockPath = path13.join(root, MEMORY_LOCK_RELPATH);
+  const pid = options.pid ?? process.pid;
+  const retries = options.retries ?? 20;
+  const minTimeoutMs = options.minTimeoutMs ?? 25;
+  const maxTimeoutMs = options.maxTimeoutMs ?? 250;
+  const pidIsRunning = options.isPidRunning ?? isPidRunning;
+  for (let attempt = 0; attempt <= retries; attempt += 1) {
+    try {
+      await fs13.writeFile(lockPath, `${pid}
+`, { encoding: "utf8", flag: "wx" });
+      try {
+        return await run();
+      } finally {
+        await removeLockFile(fs13, lockPath);
+      }
+    } catch (error) {
+      if (!hasErrorCode2(error, "EEXIST")) {
+        throw error;
+      }
+    }
+    const existingPid = await readLockPid(fs13, lockPath);
+    if (existingPid === null) {
+      continue;
+    }
+    if (existingPid === void 0 || !pidIsRunning(existingPid)) {
+      await removeLockFile(fs13, lockPath);
+      continue;
+    }
+    if (attempt < retries) {
+      await sleep(lockDelay(attempt, minTimeoutMs, maxTimeoutMs));
+    }
+  }
+  throw new Error(`Failed to acquire memory lock at "${lockPath}".`);
+}
+
+// packages/memory/src/reconcile.ts
+import { createHash } from "node:crypto";
+import * as fs5 from "node:fs/promises";
+import path14 from "node:path";
+
+// packages/memory/src/confidence.ts
+var TAG_RE = /^<!--\s*memory:(?<verb>extracted|inferred|ambiguous)(?<rest>[^>]*?)-->\s*$/;
+function parseClaims(body) {
+  const lines = normalizeNewlines(body).split("\n");
+  const claims = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const tagLine = lines[index] ?? "";
+    const match = TAG_RE.exec(tagLine);
+    if (match?.groups?.verb === void 0) {
+      continue;
+    }
+    const claimLines = [];
+    for (let claimIndex = index + 1; claimIndex < lines.length; claimIndex += 1) {
+      const line = lines[claimIndex] ?? "";
+      if (line.trim().length === 0 || TAG_RE.test(line)) {
+        break;
+      }
+      claimLines.push(line);
+    }
+    if (claimLines.length === 0) {
+      throw new Error(`Confidence tag on line ${index + 1} is not followed by a claim paragraph.`);
+    }
+    claims.push({
+      tag: parseTag(match.groups.verb, match.groups.rest ?? ""),
+      body: claimLines.join("\n"),
+      lineNumber: index + 1
+    });
+  }
+  return claims;
+}
+function serializeTag(tag) {
+  switch (tag.verb) {
+    case "extracted":
+      return serializeComment("extracted", {
+        source: serializeSourceRef(tag.source),
+        ...tag.note === void 0 ? {} : { note: tag.note }
+      });
+    case "inferred":
+      return serializeComment("inferred", {
+        confidence: serializeConfidence(tag.confidence),
+        ...tag.source === void 0 ? {} : { source: serializeSourceRef(tag.source) },
+        ...tag.note === void 0 ? {} : { note: tag.note }
+      });
+    case "ambiguous": {
+      const reason = tag.reason.trim();
+      if (reason.length === 0) {
+        throw new Error('Ambiguous confidence tags require a non-empty "reason".');
+      }
+      return serializeComment("ambiguous", { reason });
+    }
+  }
+}
+function parseTag(verb, rest) {
+  const attrs = parseAttributes(rest);
+  switch (verb) {
+    case "extracted": {
+      const source = attrs.source;
+      if (source === void 0) {
+        throw new Error('Extracted confidence tags require "source".');
+      }
+      assertOnlyKeys(attrs, verb, ["source", "note"]);
+      return {
+        verb,
+        source: parseSourceRef(source),
+        ...attrs.note === void 0 ? {} : { note: attrs.note }
+      };
+    }
+    case "inferred": {
+      const confidence = attrs.confidence;
+      if (confidence === void 0) {
+        throw new Error('Inferred confidence tags require "confidence".');
+      }
+      assertOnlyKeys(attrs, verb, ["confidence", "source", "note"]);
+      return {
+        verb,
+        confidence: parseConfidence(confidence),
+        ...attrs.source === void 0 ? {} : { source: parseSourceRef(attrs.source) },
+        ...attrs.note === void 0 ? {} : { note: attrs.note }
+      };
+    }
+    case "ambiguous": {
+      const reason = attrs.reason?.trim();
+      if (reason === void 0 || reason.length === 0) {
+        throw new Error('Ambiguous confidence tags require a non-empty "reason".');
+      }
+      assertOnlyKeys(attrs, verb, ["reason"]);
+      return {
+        verb,
+        reason
+      };
+    }
+  }
+}
+function parseAttributes(rest) {
+  const attrs = {};
+  let index = 0;
+  while (index < rest.length) {
+    index = skipWhitespace(rest, index);
+    if (index >= rest.length) {
+      break;
+    }
+    const keyStart = index;
+    while (index < rest.length && isKeyCharacter(rest[index] ?? "")) {
+      index += 1;
+    }
+    if (keyStart === index) {
+      throw new Error(`Invalid confidence tag attribute near "${rest.slice(index).trim()}".`);
+    }
+    const key = rest.slice(keyStart, index);
+    if ((rest[index] ?? "") !== "=") {
+      throw new Error(`Invalid confidence tag attribute "${key}".`);
+    }
+    index += 1;
+    const { value, nextIndex } = readAttributeValue(rest, index);
+    if (attrs[key] !== void 0) {
+      throw new Error(`Duplicate confidence tag attribute "${key}".`);
+    }
+    attrs[key] = value;
+    index = nextIndex;
+  }
+  return attrs;
+}
+function readAttributeValue(input, index) {
+  if (index >= input.length) {
+    throw new Error("Missing confidence tag attribute value.");
+  }
+  if (input[index] === '"') {
+    const endQuote = findClosingQuote(input, index + 1);
+    return {
+      value: JSON.parse(input.slice(index, endQuote + 1)),
+      nextIndex: endQuote + 1
+    };
+  }
+  let nextIndex = index;
+  while (nextIndex < input.length && !isWhitespace(input[nextIndex] ?? "")) {
+    nextIndex += 1;
+  }
+  if (nextIndex === index) {
+    throw new Error("Missing confidence tag attribute value.");
+  }
+  return {
+    value: input.slice(index, nextIndex),
+    nextIndex
+  };
+}
+function findClosingQuote(input, start) {
+  let escaped = false;
+  for (let index = start; index < input.length; index += 1) {
+    const char = input[index] ?? "";
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      return index;
+    }
+  }
+  throw new Error("Unterminated quoted confidence tag attribute.");
+}
+function assertOnlyKeys(attrs, verb, allowedKeys) {
+  const disallowedKeys = Object.keys(attrs).filter((key) => !allowedKeys.includes(key));
+  if (disallowedKeys.length > 0) {
+    throw new Error(
+      `${verb} confidence tags do not support: ${disallowedKeys.map((key) => `"${key}"`).join(", ")}.`
+    );
+  }
+}
+function parseConfidence(rawConfidence) {
+  const confidence = Number(rawConfidence);
+  if (!Number.isFinite(confidence) || confidence <= 0 || confidence > 1) {
+    throw new Error(`Invalid confidence value "${rawConfidence}". Expected a number in (0, 1].`);
+  }
+  return confidence;
+}
+function serializeComment(verb, attrs) {
+  const parts = Object.entries(attrs).map(([key, value]) => `${key}=${serializeAttributeValue(key, value)}`);
+  return `<!-- memory:${verb}${parts.length === 0 ? "" : ` ${parts.join(" ")}`} -->`;
+}
+function serializeAttributeValue(key, value) {
+  return key === "source" || key === "confidence" ? value : JSON.stringify(value);
+}
+function serializeConfidence(confidence) {
+  return String(parseConfidence(String(confidence)));
+}
+function normalizeNewlines(value) {
+  return value.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+}
+function skipWhitespace(input, index) {
+  while (index < input.length && isWhitespace(input[index] ?? "")) {
+    index += 1;
+  }
+  return index;
+}
+function isKeyCharacter(char) {
+  return char >= "a" && char <= "z" || char >= "A" && char <= "Z";
+}
+function isWhitespace(char) {
+  return char === " " || char === "	" || char === "\n" || char === "\r";
+}
+
+// packages/memory/src/reconcile.ts
+async function snapshot(root) {
+  const pages = Object.fromEntries(
+    await Promise.all(
+      (await collectMarkdownRelPaths(root, MEMORY_PAGES_DIR_RELPATH)).map(async (relPath) => [
+        relPath,
+        hashContent(await fs5.readFile(path14.join(root, relPath), "utf8"))
+      ])
+    )
+  );
+  return { pages };
+}
+async function reconcile(root, before, _verb, detail) {
+  await initMemory(root);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const currentPages = await Promise.all(
+    (await collectMarkdownRelPaths(root, MEMORY_PAGES_DIR_RELPATH)).map(async (relPath) => {
+      const absPath = path14.join(root, relPath);
+      const markdown = await fs5.readFile(absPath, "utf8");
+      const parsed = parsePageMarkdown(relPath, markdown);
+      const normalizedFrontmatter = withDenormalizedSources(parsed.frontmatter, parsed.body);
+      const normalizedMarkdown = serializeFrontmatter(normalizedFrontmatter, parsed.body);
+      const changed = before.pages[relPath] !== hashContent(normalizedMarkdown);
+      const nextMarkdown = changed ? serializeFrontmatter(
+        {
+          ...normalizedFrontmatter,
+          lastTouchedAt: timestamp
+        },
+        parsed.body
+      ) : normalizedMarkdown;
+      return {
+        relPath,
+        changed,
+        currentMarkdown: markdown,
+        nextMarkdown
+      };
+    })
+  );
+  await Promise.all(
+    currentPages.filter((page) => page.currentMarkdown !== page.nextMarkdown).map((page) => fs5.writeFile(path14.join(root, page.relPath), page.nextMarkdown, "utf8"))
+  );
+  const diff = diffSnapshots(before, await snapshot(root));
+  await writeIndex(root);
+  await appendLogEntries(root, diff, detail, timestamp);
+  return diff;
+}
+function renderIndex(entries) {
+  if (entries.length === 0) {
+    return "# Memory index\n";
+  }
+  return [
+    "# Memory index",
+    "",
+    ...entries.map(({ relPath, description }) => {
+      const pageName = relPath.slice(`${MEMORY_PAGES_DIR_RELPATH}/`.length).replace(/\.md$/i, "");
+      return description.length === 0 ? `- [${pageName}](${relPath})` : `- [${pageName}](${relPath}) \u2014 ${description}`;
+    }),
+    ""
+  ].join("\n");
+}
+async function appendLogEntries(root, diff, detail, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+  const entries = [
+    ...diff.updated.map((relPath) => formatLogLine(timestamp, "update", relPath, detail)),
+    ...diff.deleted.map((relPath) => formatLogLine(timestamp, "delete", relPath, detail)),
+    ...diff.created.map((relPath) => formatLogLine(timestamp, "create", relPath, detail))
+  ];
+  if (entries.length === 0) {
+    return;
+  }
+  const logPath = path14.join(root, MEMORY_LOG_RELPATH);
+  const existing = await fs5.readFile(logPath, "utf8");
+  const separator = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
+  await fs5.writeFile(logPath, `${existing}${separator}${entries.join("\n")}
+`, "utf8");
+}
+function denormalizeSources(markdown) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const claim of parseClaims(parsePageMarkdown("inline-memory-page", markdown).body)) {
+    const source = "source" in claim.tag ? claim.tag.source : void 0;
+    if (source === void 0) {
+      continue;
+    }
+    seen.set(serializeSourceRef(source), source);
+  }
+  return Array.from(seen.entries()).sort(([left], [right]) => left.localeCompare(right)).map(([, source]) => source);
+}
+async function writeIndex(root) {
+  const index = renderIndex(
+    (await listPages(root)).map((page) => ({
+      relPath: page.relPath,
+      description: page.frontmatter.description ?? ""
+    }))
+  );
+  await fs5.writeFile(path14.join(root, MEMORY_INDEX_RELPATH), index, "utf8");
+}
+function parsePageMarkdown(relPath, markdown) {
+  try {
+    return parseFrontmatter(markdown);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Failed to parse frontmatter for "${relPath}": ${message}`);
+    return {
+      frontmatter: {},
+      body: markdown
+    };
+  }
+}
+function withDenormalizedSources(frontmatter, body) {
+  const sources = denormalizeSources(body);
+  return {
+    ...frontmatter,
+    ...sources.length === 0 ? { sources: void 0 } : { sources }
+  };
+}
+function diffSnapshots(before, after) {
+  const created = Object.keys(after.pages).filter((relPath) => before.pages[relPath] === void 0).sort((left, right) => left.localeCompare(right));
+  const updated = Object.keys(after.pages).filter(
+    (relPath) => before.pages[relPath] !== void 0 && before.pages[relPath] !== after.pages[relPath]
+  ).sort((left, right) => left.localeCompare(right));
+  const deleted = Object.keys(before.pages).filter((relPath) => after.pages[relPath] === void 0).sort((left, right) => left.localeCompare(right));
+  return {
+    created,
+    updated,
+    deleted
+  };
+}
+function formatLogLine(timestamp, verb, relPath, detail) {
+  return `- ${timestamp}  **${verb}** \`${relPath}\` \u2014 ${detail}`;
+}
+function hashContent(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+
+// packages/memory/src/write.ts
+async function writePage(root, relPath, body, opts) {
+  const pageRelPath = assertPageRelPath(relPath);
+  return withLock(root, async () => {
+    const before = await snapshot(root);
+    await fs6.mkdir(path15.dirname(path15.join(root, pageRelPath)), { recursive: true });
+    await fs6.writeFile(
+      path15.join(root, pageRelPath),
+      serializeFrontmatter(opts.frontmatter ?? {}, body),
+      "utf8"
+    );
+    return reconcile(root, before, "update", opts.reason);
+  });
+}
+async function appendToPage(root, relPath, content, opts) {
+  const pageRelPath = assertPageRelPath(relPath);
+  return withLock(root, async () => {
+    const before = await snapshot(root);
+    const pagePath = path15.join(root, pageRelPath);
+    await fs6.mkdir(path15.dirname(pagePath), { recursive: true });
+    const existing = await readMarkdownIfPresent(pagePath);
+    const parsed = existing === void 0 ? { frontmatter: {}, body: "" } : parseFrontmatter(existing);
+    await fs6.writeFile(
+      pagePath,
+      serializeFrontmatter(parsed.frontmatter, `${parsed.body}${content}`),
+      "utf8"
+    );
+    return reconcile(root, before, "update", opts.reason);
+  });
+}
+async function clearMemory(root) {
+  await withLock(root, async () => {
+    await removeChildren(root);
+    await initMemory(root);
+  });
+}
+async function removeChildren(directoryPath) {
+  for (const entryName of await fs6.readdir(directoryPath)) {
+    if (entryName === MEMORY_LOCK_RELPATH) {
+      continue;
+    }
+    const entryPath = path15.join(directoryPath, entryName);
+    const stat6 = await fs6.stat(entryPath);
+    if (stat6.isDirectory()) {
+      await removeDirectory2(entryPath);
+      continue;
+    }
+    if (stat6.isFile()) {
+      await fs6.unlink(entryPath);
+    }
+  }
+}
+async function removeDirectory2(directoryPath) {
+  await removeChildren(directoryPath);
+  await fs6.rmdir(directoryPath);
+}
+function assertPageRelPath(relPath) {
+  const normalizedRelPath = assertSafeRelPath(relPath);
+  if (!normalizedRelPath.startsWith(`${MEMORY_PAGES_DIR_RELPATH}/`) || path15.posix.extname(normalizedRelPath).toLowerCase() !== ".md") {
+    throw new Error(`Expected a markdown page path under "${MEMORY_PAGES_DIR_RELPATH}/".`);
+  }
+  return normalizedRelPath;
+}
+async function readMarkdownIfPresent(filePath) {
+  try {
+    return await fs6.readFile(filePath, "utf8");
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+}
+
+// packages/memory/src/edit.ts
+async function editPage(root, relPath, opts) {
+  const pagePath = path16.join(root, relPath);
+  const original = await readIfPresent(pagePath);
+  const tempRoot = path16.join(root, ".tmp");
+  await fs7.mkdir(tempRoot, { recursive: true });
+  const tempDir = await fs7.mkdtemp(path16.join(tempRoot, "poe-code-memory-edit-"));
+  const tempPath = path16.join(tempDir, path16.basename(relPath));
+  try {
+    await fs7.writeFile(tempPath, original ?? "", "utf8");
+    await opts.launchEditor(tempPath);
+    const edited = await fs7.readFile(tempPath, "utf8");
+    if (edited === (original ?? "")) {
+      return { changed: false };
+    }
+    const parsed = parseFrontmatter(edited);
+    const diff = await writePage(root, relPath, parsed.body, {
+      frontmatter: parsed.frontmatter,
+      reason: opts.reason
+    });
+    return {
+      changed: true,
+      diff
+    };
+  } finally {
+    await fs7.rm(tempDir, { recursive: true, force: true });
+  }
+}
+async function readIfPresent(filePath) {
+  try {
+    return await fs7.readFile(filePath, "utf8");
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+}
+
+// packages/memory/src/audit.ts
+import * as fs8 from "node:fs/promises";
+import path17 from "node:path";
+var DEFAULT_MIN_INFERRED_CONFIDENCE = 0.3;
+var DEFAULT_REJECT_UNTAGGED = false;
+var DEFAULT_UNTAGGED_BODY_THRESHOLD_CHARS = 200;
+async function auditClaims(root, repoRoot, options = {}) {
+  const minInferredConfidence = options.minInferredConfidence ?? DEFAULT_MIN_INFERRED_CONFIDENCE;
+  const rejectUntagged = options.rejectUntagged ?? DEFAULT_REJECT_UNTAGGED;
+  const untaggedBodyThresholdChars = options.untaggedBodyThresholdChars ?? DEFAULT_UNTAGGED_BODY_THRESHOLD_CHARS;
+  const sourceCache = /* @__PURE__ */ new Map();
+  const pages = await listPages(root);
+  const audits = [];
+  for (const page of pages) {
+    const issues = [];
+    let claims;
+    try {
+      claims = parseClaims(page.body);
+    } catch (error) {
+      issues.push(formatError(error));
+      audits.push({ page: page.relPath, issues });
+      continue;
+    }
+    if (rejectUntagged && claims.length === 0 && page.body.trim().length > untaggedBodyThresholdChars) {
+      issues.push(
+        `Page has a long untagged body (>${untaggedBodyThresholdChars} chars) with no memory:* tags.`
+      );
+    }
+    const inlineSources = /* @__PURE__ */ new Set();
+    for (const claim of claims) {
+      if (claim.tag.verb === "inferred" && claim.tag.confidence < minInferredConfidence) {
+        issues.push(
+          `Claim on line ${claim.lineNumber} uses inferred confidence=${claim.tag.confidence}, below the minimum ${minInferredConfidence}.`
+        );
+      }
+      const source = "source" in claim.tag ? claim.tag.source : void 0;
+      if (source === void 0) {
+        continue;
+      }
+      const serializedSource = serializeSourceRef(source);
+      inlineSources.add(serializedSource);
+      const sourceIssue = await auditSourceRef(source, claim.lineNumber, repoRoot, sourceCache);
+      if (sourceIssue !== void 0) {
+        issues.push(sourceIssue);
+      }
+    }
+    issues.push(...auditFrontmatterSources(page.frontmatter.sources ?? [], inlineSources));
+    if (issues.length > 0) {
+      audits.push({ page: page.relPath, issues });
+    }
+  }
+  return audits;
+}
+async function auditSourceRef(source, claimLineNumber, repoRoot, sourceCache) {
+  if (isUrlLike(source.path)) {
+    return void 0;
+  }
+  if (path17.isAbsolute(source.path)) {
+    return `Claim on line ${claimLineNumber} cites "${serializeSourceRef(source)}", but source paths must be repo-relative or URLs.`;
+  }
+  const absPath = path17.resolve(repoRoot, source.path);
+  if (!isWithinRoot(repoRoot, absPath)) {
+    return `Claim on line ${claimLineNumber} cites "${serializeSourceRef(source)}", which resolves outside the repo root.`;
+  }
+  const meta = await readSourceFile(absPath, sourceCache);
+  if (!meta.exists) {
+    return `Claim on line ${claimLineNumber} cites "${serializeSourceRef(source)}", resolved to "${meta.absPath}", but the file does not exist.`;
+  }
+  const lastReferencedLine = source.endLine ?? source.startLine;
+  if (lastReferencedLine !== void 0 && lastReferencedLine > meta.lineCount) {
+    return `Claim on line ${claimLineNumber} cites "${serializeSourceRef(source)}", but current EOF ${meta.lineCount} is before the referenced line.`;
+  }
+  return void 0;
+}
+function auditFrontmatterSources(frontmatterSources, inlineSources) {
+  const serializedFrontmatterSources = new Set(frontmatterSources.map((source) => serializeSourceRef(source)));
+  const issues = [];
+  const missingSources = [...inlineSources].filter((source) => !serializedFrontmatterSources.has(source));
+  for (const source of missingSources.sort((left, right) => left.localeCompare(right))) {
+    issues.push(`Page frontmatter sources are missing "${source}" from inline tags.`);
+  }
+  const staleSources = [...serializedFrontmatterSources].filter((source) => !inlineSources.has(source));
+  for (const source of staleSources.sort((left, right) => left.localeCompare(right))) {
+    issues.push(`Page frontmatter sources contain stale entry "${source}" not found in inline tags.`);
+  }
+  return issues;
+}
+function readSourceFile(absPath, sourceCache) {
+  const cached = sourceCache.get(absPath);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const pending = fs8.readFile(absPath, "utf8").then((content) => ({
+    exists: true,
+    absPath,
+    lineCount: countLines(content)
+  })).catch((error) => {
+    if (isMissing2(error)) {
+      return {
+        exists: false,
+        absPath
+      };
+    }
+    throw error;
+  });
+  sourceCache.set(absPath, pending);
+  return pending;
+}
+function countLines(content) {
+  if (content.length === 0) {
+    return 0;
+  }
+  const normalized = content.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+  const trimmed = normalized.endsWith("\n") ? normalized.slice(0, -1) : normalized;
+  return trimmed.length === 0 ? 0 : trimmed.split("\n").length;
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isMissing2(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function isUrlLike(value) {
+  return /^[a-z][a-z\d+.-]*:\/\//i.test(value);
+}
+function isWithinRoot(root, absPath) {
+  const relative = path17.relative(root, absPath);
+  return relative === "" || !relative.startsWith("..") && !path17.isAbsolute(relative);
+}
+
+// packages/memory/src/cache.ts
+import { createHash as createHash2 } from "node:crypto";
+import * as fs9 from "node:fs/promises";
+import path18 from "node:path";
+function computeIngestKey(input) {
+  const hash = createHash2("sha256");
+  hash.update(input.sourceBytes);
+  hash.update("\0");
+  hash.update(input.indexMdBytes);
+  hash.update("\0");
+  hash.update(input.promptTemplateVersion);
+  hash.update("\0");
+  hash.update(input.agentId);
+  return hash.digest("hex");
+}
+async function readCacheEntry(root, key) {
+  const cachePath = path18.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH, `${key}.json`);
+  let raw;
+  try {
+    raw = await fs9.readFile(cachePath, "utf8");
+  } catch (error) {
+    if (isMissing3(error)) {
+      return null;
+    }
+    throw error;
+  }
+  try {
+    return parseCacheEntry(JSON.parse(raw), key);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Ignoring ingest cache entry "${key}": ${message}`);
+    return null;
+  }
+}
+async function writeCacheEntry(root, entry) {
+  await fs9.mkdir(path18.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH), { recursive: true });
+  await fs9.writeFile(
+    path18.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH, `${entry.key}.json`),
+    `${JSON.stringify(entry)}
+`,
+    "utf8"
+  );
+}
+async function clearCache(root, opts = {}) {
+  const ingestDir = path18.join(root, MEMORY_INGEST_CACHE_DIR_RELPATH);
+  const cacheDir = path18.join(root, MEMORY_CACHE_DIR_RELPATH);
+  const fileNames = await readCacheFileNames(ingestDir);
+  if (fileNames.length === 0) {
+    if (opts.olderThanMs === void 0) {
+      await fs9.rm(cacheDir, { recursive: true, force: true });
+    }
+    return { removed: 0 };
+  }
+  if (opts.olderThanMs === void 0) {
+    await fs9.rm(cacheDir, { recursive: true, force: true });
+    return { removed: fileNames.length };
+  }
+  const cutoff = Date.now() - opts.olderThanMs;
+  let removed = 0;
+  for (const fileName of fileNames) {
+    const key = fileName.slice(0, -".json".length);
+    const entry = await readCacheEntry(root, key);
+    if (entry === null || Date.parse(entry.ingestedAt) > cutoff) {
+      continue;
+    }
+    await fs9.rm(path18.join(ingestDir, fileName), { force: true });
+    removed += 1;
+  }
+  await removeEmptyDirectory(ingestDir);
+  await removeEmptyDirectory(cacheDir);
+  return { removed };
+}
+function parseCacheEntry(value, key) {
+  const object = expectRecord(value);
+  return {
+    key: expectString(object.key, "key"),
+    ingestedAt: expectString(object.ingestedAt, "ingestedAt"),
+    sourceLabel: expectString(object.sourceLabel, "sourceLabel"),
+    diff: parseMemoryDiff(object.diff),
+    exitCode: expectNumber(object.exitCode, "exitCode"),
+    durationMs: expectNumber(object.durationMs, "durationMs"),
+    memoryTokens: expectNumber(object.memoryTokens, "memoryTokens"),
+    sourceTokens: expectNumber(object.sourceTokens, "sourceTokens"),
+    promptTemplateVersion: expectString(object.promptTemplateVersion, "promptTemplateVersion"),
+    agentId: expectString(object.agentId, "agentId")
+  };
+}
+function parseMemoryDiff(value) {
+  const object = expectRecord(value);
+  return {
+    created: expectStringArray(object.created, "diff.created"),
+    updated: expectStringArray(object.updated, "diff.updated"),
+    deleted: expectStringArray(object.deleted, "diff.deleted")
+  };
+}
+function expectRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error("Expected a JSON object.");
+  }
+  return value;
+}
+function expectString(value, field) {
+  if (typeof value !== "string") {
+    throw new Error(`Expected string at "${field}".`);
+  }
+  return value;
+}
+function expectNumber(value, field) {
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    throw new Error(`Expected number at "${field}".`);
+  }
+  return value;
+}
+function expectStringArray(value, field) {
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+    throw new Error(`Expected string[] at "${field}".`);
+  }
+  return value;
+}
+async function readCacheFileNames(ingestDir) {
+  try {
+    return (await fs9.readdir(ingestDir)).filter((fileName) => path18.posix.extname(fileName).toLowerCase() === ".json").sort((left, right) => left.localeCompare(right));
+  } catch (error) {
+    if (isMissing3(error)) {
+      return [];
+    }
+    throw error;
+  }
+}
+async function removeEmptyDirectory(directoryPath) {
+  try {
+    const remainingEntries = await fs9.readdir(directoryPath);
+    if (remainingEntries.length === 0) {
+      await fs9.rmdir(directoryPath);
+    }
+  } catch (error) {
+    if (isMissing3(error)) {
+      return;
+    }
+    throw error;
+  }
+}
+function isMissing3(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// packages/memory/src/cache.cli.ts
+import parseDuration from "parse-duration";
+async function runMemoryCacheStatus() {
+  console.log("cache status not implemented yet");
+}
+async function runMemoryCacheClear(input) {
+  if (!input.yes) {
+    throw new Error("Refusing to clear cache without --yes.");
+  }
+  const olderThanMs = parseOlderThan(input.olderThan);
+  const result = await clearCache(input.root, olderThanMs === void 0 ? {} : { olderThanMs });
+  console.log(`removed ${result.removed} cache ${result.removed === 1 ? "entry" : "entries"}`);
+  return result;
+}
+function parseOlderThan(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const duration = parseDuration(value);
+  if (duration === null || Number.isNaN(duration) || duration < 0) {
+    throw new Error(`Invalid duration for --older-than: "${value}".`);
+  }
+  return duration;
+}
+
+// packages/memory/src/ingest.ts
+import * as fs11 from "node:fs/promises";
+import path20 from "node:path";
+
+// packages/memory/src/tokens.ts
+import * as fs10 from "node:fs/promises";
+import path19 from "node:path";
+
+// packages/tokenfill/src/tokenizer.ts
+import { get_encoding } from "tiktoken";
+var DEFAULT_ENCODING = "cl100k_base";
+function createTokenizer(options = {}) {
+  const encoding = options.encoding ?? DEFAULT_ENCODING;
+  const tokenizer = get_encoding(encoding);
+  const utf8Decoder = new TextDecoder();
+  const encode = (text) => tokenizer.encode(text);
+  const decode = (tokens) => {
+    const tokenArray = tokens instanceof Uint32Array ? tokens : Uint32Array.from(tokens);
+    return utf8Decoder.decode(tokenizer.decode(tokenArray));
+  };
+  const count = (text) => encode(text).length;
+  const truncate = (text, tokenCount) => {
+    if (tokenCount <= 0) {
+      return "";
+    }
+    const tokens = encode(text);
+    if (tokens.length <= tokenCount) {
+      return text;
+    }
+    return decode(tokens.slice(0, tokenCount));
+  };
+  return {
+    encoding,
+    encode,
+    decode,
+    count,
+    truncate,
+    free: () => tokenizer.free()
+  };
+}
+var defaultTokenizer;
+function countTokens(text) {
+  defaultTokenizer ??= createTokenizer();
+  return defaultTokenizer.count(text);
+}
+
+// packages/tokenfill/src/corpus.ts
+import { readdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var CORPUS_ARTICLE_SEPARATOR = "\n\n";
+var corpusDirectoryPath = join(dirname(fileURLToPath(import.meta.url)), "corpus");
+function getCorpusFileNames() {
+  return readdirSync(corpusDirectoryPath, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => entry.name).sort((left, right) => left.localeCompare(right));
+}
+function loadBuiltInCorpusArticles() {
+  const corpusFileNames = getCorpusFileNames();
+  if (corpusFileNames.length === 0) {
+    throw new Error(`No built-in corpus markdown files found in ${corpusDirectoryPath}`);
+  }
+  return corpusFileNames.map((fileName) => readFileSync(join(corpusDirectoryPath, fileName), "utf8").trim());
+}
+var BUILT_IN_CORPUS_ARTICLES = loadBuiltInCorpusArticles();
+
+// packages/tokenfill/src/tokenfill.ts
+var builtInCorpusText = BUILT_IN_CORPUS_ARTICLES.join(CORPUS_ARTICLE_SEPARATOR);
+var builtInCorpusByteLength = Buffer.byteLength(builtInCorpusText, "utf8");
+
+// packages/memory/src/tokens.ts
+async function computeTokenStats(root) {
+  if (!await pathExists3(root)) {
+    return {
+      memoryTokens: 0,
+      sourceTokens: 0,
+      reductionRatio: 0,
+      missingSources: []
+    };
+  }
+  const pages = await listPages(root);
+  let memoryTokens = 0;
+  const sourcePaths = /* @__PURE__ */ new Set();
+  for (const page of pages) {
+    memoryTokens += countTokens(page.body);
+    for (const source of page.frontmatter.sources ?? []) {
+      const normalized = source.path.trim();
+      if (normalized.length > 0) {
+        sourcePaths.add(normalized);
+      }
+    }
+  }
+  const repoRoot = path19.resolve(root, "..", "..");
+  let sourceTokens = 0;
+  const missingSources = [];
+  for (const sourcePath of sourcePaths) {
+    const absPath = path19.isAbsolute(sourcePath) ? sourcePath : path19.resolve(repoRoot, sourcePath);
+    try {
+      const content = await fs10.readFile(absPath, "utf8");
+      sourceTokens += countTokens(content);
+    } catch (error) {
+      if (isMissing4(error)) {
+        missingSources.push(sourcePath);
+        continue;
+      }
+      throw error;
+    }
+  }
+  missingSources.sort((left, right) => left.localeCompare(right));
+  const reductionRatio = sourceTokens === 0 ? 0 : sourceTokens / Math.max(memoryTokens, 1);
+  return {
+    memoryTokens,
+    sourceTokens,
+    reductionRatio,
+    missingSources
+  };
+}
+async function pathExists3(targetPath) {
+  try {
+    await fs10.stat(targetPath);
+    return true;
+  } catch (error) {
+    if (isMissing4(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+function isMissing4(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// packages/memory/src/ingest.ts
+var INGEST_PROMPT_VERSION = "v1";
+async function ingest(root, opts) {
+  const source = await materializeSource(opts.source);
+  const indexMdBytes = await fs11.readFile(path20.join(root, MEMORY_INDEX_RELPATH));
+  const configOptions = {
+    fs: fs11,
+    filePath: path20.join(inferRepoRoot(root), "poe-code.json")
+  };
+  const agentId = await resolveAgent(configOptions, opts.agent ?? null) ?? opts.agent ?? "claude-code";
+  const key = computeIngestKey({
+    sourceBytes: source.bytes,
+    indexMdBytes,
+    promptTemplateVersion: INGEST_PROMPT_VERSION,
+    agentId
+  });
+  if (!opts.force && await cacheEnabled(configOptions)) {
+    const hit = await readCacheEntry(root, key);
+    if (hit !== null) {
+      return {
+        diff: { created: [], updated: [], deleted: [] },
+        exitCode: 0,
+        durationMs: 0,
+        cacheHit: true,
+        tokens: await computeTokenStats(root)
+      };
+    }
+  }
+  const prompt = buildIngestPrompt(root, source.label, source.text);
+  if (opts.dryRun) {
+    console.log(prompt);
+    return {
+      diff: { created: [], updated: [], deleted: [] },
+      exitCode: 0,
+      durationMs: 0,
+      cacheHit: false,
+      tokens: await computeTokenStats(root)
+    };
+  }
+  const before = await snapshot(root);
+  let exitCode = 1;
+  let durationMs = 0;
+  let timeoutError;
+  try {
+    const spawnFn = opts.spawnFn;
+    const result = await runWithTimeout(
+      spawnFn?.(agentId, prompt) ?? Promise.resolve({ exitCode: 0, durationMs: 0 }),
+      opts.timeoutMs ?? await configuredTimeout(configOptions)
+    );
+    exitCode = result.exitCode;
+    durationMs = result.durationMs;
+  } catch (error) {
+    timeoutError = error instanceof Error ? error : new Error(String(error));
+  }
+  const diff = await reconcile(root, before, "ingest", opts.reason ?? `ingest ${source.label}`);
+  const tokens = await computeTokenStats(root);
+  if (timeoutError !== void 0) {
+    throw timeoutError;
+  }
+  if (!opts.noCacheWrite && await cacheEnabled(configOptions) && exitCode === 0) {
+    await writeCacheEntry(root, {
+      key,
+      ingestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      sourceLabel: source.label,
+      diff,
+      exitCode,
+      durationMs,
+      memoryTokens: tokens.memoryTokens,
+      sourceTokens: tokens.sourceTokens,
+      promptTemplateVersion: INGEST_PROMPT_VERSION,
+      agentId
+    });
+  }
+  return { diff, exitCode, durationMs, cacheHit: false, tokens };
+}
+function buildIngestPrompt(root, sourceLabel, sourceText) {
+  return [
+    `Prompt version: ${INGEST_PROMPT_VERSION}`,
+    `Memory root: ${root}`,
+    `Source: ${sourceLabel}`,
+    "Update memory pages under pages/ only. Do not edit INDEX.md directly.",
+    "Add confidence tags to non-trivial claims.",
+    "",
+    sourceText
+  ].join("\n");
+}
+async function materializeSource(source) {
+  if (source.kind === "file") {
+    const bytes = await fs11.readFile(source.absPath);
+    return {
+      label: source.absPath,
+      bytes,
+      text: bytes.toString("utf8")
+    };
+  }
+  throw new Error("URL ingest not implemented yet.");
+}
+function inferRepoRoot(root) {
+  return path20.resolve(root, "..", "..");
+}
+async function runWithTimeout(promise, timeoutMs) {
+  return await new Promise((resolve2, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error(`ingest timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve2(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
+
+// packages/tiny-stdio-mcp-server/src/server.ts
+import * as readline from "readline";
+
+// packages/tiny-stdio-mcp-server/src/types.ts
+var JSON_RPC_ERROR_CODES = {
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603
+};
+var ToolError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ToolError";
+  }
+};
+
+// packages/tiny-stdio-mcp-server/src/jsonrpc.ts
+function parseMessage(line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return {
+      success: false,
+      error: {
+        code: JSON_RPC_ERROR_CODES.PARSE_ERROR,
+        message: "Parse error"
+      },
+      id: null
+    };
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return {
+      success: false,
+      error: {
+        code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
+        message: "Invalid Request"
+      },
+      id: null
+    };
+  }
+  const obj = parsed;
+  const hasId = "id" in obj;
+  const id = typeof obj.id === "string" || typeof obj.id === "number" ? obj.id : null;
+  if (obj.jsonrpc !== "2.0") {
+    return {
+      success: false,
+      error: {
+        code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
+        message: "Invalid Request"
+      },
+      id
+    };
+  }
+  if (typeof obj.method !== "string") {
+    return {
+      success: false,
+      error: {
+        code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
+        message: "Invalid Request"
+      },
+      id
+    };
+  }
+  if (!hasId) {
+    return {
+      success: true,
+      isNotification: true,
+      request: {
+        jsonrpc: "2.0",
+        method: obj.method,
+        params: obj.params
+      }
+    };
+  }
+  if (id === null) {
+    return {
+      success: false,
+      error: {
+        code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
+        message: "Invalid Request"
+      },
+      id: null
+    };
+  }
+  return {
+    success: true,
+    isNotification: false,
+    request: {
+      jsonrpc: "2.0",
+      id,
+      method: obj.method,
+      params: obj.params
+    }
+  };
+}
+function formatSuccessResponse(id, result) {
+  const response = {
+    jsonrpc: "2.0",
+    id,
+    result
+  };
+  return JSON.stringify(response);
+}
+function formatErrorResponse(id, error) {
+  const response = {
+    jsonrpc: "2.0",
+    id,
+    error
+  };
+  return JSON.stringify(response);
+}
+
+// packages/tiny-stdio-mcp-server/src/content/file-type.ts
+function fileTypeFromBuffer(data) {
+  if (data.length < 12) {
+    return void 0;
+  }
+  if (data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71 && data[4] === 13 && data[5] === 10 && data[6] === 26 && data[7] === 10) {
+    return { mime: "image/png", ext: "png" };
+  }
+  if (data[0] === 255 && data[1] === 216 && data[2] === 255) {
+    return { mime: "image/jpeg", ext: "jpg" };
+  }
+  if (data[0] === 71 && data[1] === 73 && data[2] === 70 && data[3] === 56) {
+    return { mime: "image/gif", ext: "gif" };
+  }
+  if (data[0] === 82 && data[1] === 73 && data[2] === 70 && data[3] === 70 && data[8] === 87 && data[9] === 69 && data[10] === 66 && data[11] === 80) {
+    return { mime: "image/webp", ext: "webp" };
+  }
+  if (data[0] === 255 && (data[1] === 251 || data[1] === 250) || data[0] === 73 && data[1] === 68 && data[2] === 51) {
+    return { mime: "audio/mpeg", ext: "mp3" };
+  }
+  if (data[0] === 82 && data[1] === 73 && data[2] === 70 && data[3] === 70 && data[8] === 87 && data[9] === 65 && data[10] === 86 && data[11] === 69) {
+    return { mime: "audio/wav", ext: "wav" };
+  }
+  if (data[0] === 79 && data[1] === 103 && data[2] === 103 && data[3] === 83) {
+    return { mime: "audio/ogg", ext: "ogg" };
+  }
+  if (data[4] === 102 && data[5] === 116 && data[6] === 121 && data[7] === 112 && data[8] === 77 && data[9] === 52 && data[10] === 65) {
+    return { mime: "audio/mp4", ext: "m4a" };
+  }
+  if (data[4] === 102 && data[5] === 116 && data[6] === 121 && data[7] === 112) {
+    return { mime: "video/mp4", ext: "mp4" };
+  }
+  if (data[0] === 26 && data[1] === 69 && data[2] === 223 && data[3] === 163) {
+    return { mime: "video/webm", ext: "webm" };
+  }
+  return void 0;
+}
+
+// packages/tiny-stdio-mcp-server/src/content/image.ts
+var SUPPORTED_IMAGE_MIMES = /* @__PURE__ */ new Set([
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp"
+]);
+var Image = class _Image {
+  constructor(base64Data, mimeType) {
+    this.base64Data = base64Data;
+    this.mimeType = mimeType;
+  }
+  static async fromUrl(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch image from ${url}: ${response.status} ${response.statusText}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const data = new Uint8Array(arrayBuffer);
+    const detected = fileTypeFromBuffer(data);
+    let mimeType;
+    if (detected && SUPPORTED_IMAGE_MIMES.has(detected.mime)) {
+      mimeType = detected.mime;
+    } else {
+      const contentType = response.headers.get("content-type")?.split(";")[0];
+      if (contentType && SUPPORTED_IMAGE_MIMES.has(contentType)) {
+        mimeType = contentType;
+      } else {
+        throw new Error(`Unable to detect image MIME type from ${url}`);
+      }
+    }
+    const base64 = Buffer.from(data).toString("base64");
+    return new _Image(base64, mimeType);
+  }
+  static fromBytes(data, format) {
+    let mimeType;
+    if (format) {
+      mimeType = format.includes("/") ? format : `image/${format}`;
+    } else {
+      const detected = fileTypeFromBuffer(data);
+      if (!detected || !SUPPORTED_IMAGE_MIMES.has(detected.mime)) {
+        throw new Error("Unable to detect image MIME type from bytes");
+      }
+      mimeType = detected.mime;
+    }
+    const base64 = Buffer.from(data).toString("base64");
+    return new _Image(base64, mimeType);
+  }
+  static fromBase64(base64, mimeType) {
+    return new _Image(base64, mimeType);
+  }
+  toContentBlock() {
+    return {
+      type: "image",
+      data: this.base64Data,
+      mimeType: this.mimeType
+    };
+  }
+};
+
+// packages/tiny-stdio-mcp-server/src/content/audio.ts
+var SUPPORTED_AUDIO_MIMES = /* @__PURE__ */ new Set([
+  "audio/mpeg",
+  "audio/wav",
+  "audio/ogg",
+  "audio/mp4"
+]);
+var AUDIO_FORMAT_MAP = {
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  m4a: "audio/mp4",
+  mpeg: "audio/mpeg"
+};
+var Audio = class _Audio {
+  constructor(base64Data, mimeType) {
+    this.base64Data = base64Data;
+    this.mimeType = mimeType;
+  }
+  static async fromUrl(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch audio from ${url}: ${response.status} ${response.statusText}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const data = new Uint8Array(arrayBuffer);
+    const detected = fileTypeFromBuffer(data);
+    let mimeType;
+    if (detected && SUPPORTED_AUDIO_MIMES.has(detected.mime)) {
+      mimeType = detected.mime;
+    } else {
+      const contentType = response.headers.get("content-type")?.split(";")[0];
+      if (contentType && SUPPORTED_AUDIO_MIMES.has(contentType)) {
+        mimeType = contentType;
+      } else {
+        throw new Error(`Unable to detect audio MIME type from ${url}`);
+      }
+    }
+    const base64 = Buffer.from(data).toString("base64");
+    return new _Audio(base64, mimeType);
+  }
+  static fromBytes(data, format) {
+    let mimeType;
+    if (format) {
+      if (format.includes("/")) {
+        mimeType = format;
+      } else {
+        mimeType = AUDIO_FORMAT_MAP[format.toLowerCase()] || `audio/${format}`;
+      }
+    } else {
+      const detected = fileTypeFromBuffer(data);
+      if (!detected || !SUPPORTED_AUDIO_MIMES.has(detected.mime)) {
+        throw new Error("Unable to detect audio MIME type from bytes");
+      }
+      mimeType = detected.mime;
+    }
+    const base64 = Buffer.from(data).toString("base64");
+    return new _Audio(base64, mimeType);
+  }
+  static fromBase64(base64, mimeType) {
+    return new _Audio(base64, mimeType);
+  }
+  toContentBlock() {
+    return {
+      type: "audio",
+      data: this.base64Data,
+      mimeType: this.mimeType
+    };
+  }
+};
+
+// packages/tiny-stdio-mcp-server/src/content/file.ts
+function isTextMimeType(mimeType) {
+  return mimeType.startsWith("text/") || mimeType === "application/json" || mimeType === "application/xml" || mimeType === "application/javascript" || mimeType === "application/typescript";
+}
+var File = class _File {
+  constructor(data, mimeType, isText, name) {
+    this.data = data;
+    this.mimeType = mimeType;
+    this.isText = isText;
+    this.name = name;
+  }
+  static async fromUrl(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch file from ${url}: ${response.status} ${response.statusText}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const data = new Uint8Array(arrayBuffer);
+    const detected = fileTypeFromBuffer(data);
+    let mimeType;
+    if (detected) {
+      mimeType = detected.mime;
+    } else {
+      const contentType = response.headers.get("content-type")?.split(";")[0];
+      if (contentType) {
+        mimeType = contentType;
+      } else {
+        throw new Error(`Unable to detect MIME type from ${url}`);
+      }
+    }
+    const isText = isTextMimeType(mimeType);
+    const name = url.split("/").pop() || "file";
+    return new _File(data, mimeType, isText, name);
+  }
+  static fromBytes(data, mimeType) {
+    const isText = isTextMimeType(mimeType);
+    return new _File(data, mimeType, isText);
+  }
+  static fromText(text, mimeType = "text/plain") {
+    return new _File(text, mimeType, true);
+  }
+  static fromBase64(base64, mimeType) {
+    const data = Buffer.from(base64, "base64");
+    const isText = isTextMimeType(mimeType);
+    return new _File(new Uint8Array(data), mimeType, isText);
+  }
+  toContentBlock() {
+    const uri = this.name ? `file:///${this.name}` : "file:///data";
+    if (this.isText) {
+      let text;
+      if (typeof this.data === "string") {
+        text = this.data;
+      } else {
+        text = new TextDecoder("utf-8").decode(this.data);
+      }
+      return {
+        type: "resource",
+        resource: {
+          uri,
+          mimeType: this.mimeType,
+          text
+        }
+      };
+    } else {
+      let blob;
+      if (typeof this.data === "string") {
+        blob = Buffer.from(this.data).toString("base64");
+      } else {
+        blob = Buffer.from(this.data).toString("base64");
+      }
+      return {
+        type: "resource",
+        resource: {
+          uri,
+          mimeType: this.mimeType,
+          blob
+        }
+      };
+    }
+  }
+};
+
+// packages/tiny-stdio-mcp-server/src/content/convert.ts
+function convertSingleValue(value) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return { type: "text", text: String(value) };
+  }
+  if (value === null) {
+    return { type: "text", text: "null" };
+  }
+  if (value instanceof Image) {
+    return value.toContentBlock();
+  }
+  if (value instanceof Audio) {
+    return value.toContentBlock();
+  }
+  if (value instanceof File) {
+    return value.toContentBlock();
+  }
+  if (isContentBlock(value)) {
+    return value;
+  }
+  return { type: "text", text: JSON.stringify(value) };
+}
+function toContentBlocks(result) {
+  if (result === void 0) {
+    return [];
+  }
+  if (Array.isArray(result)) {
+    return result.flatMap((item) => toContentBlocks(item));
+  }
+  return [convertSingleValue(result)];
+}
+function isContentBlock(value) {
+  if (!("type" in value) || typeof value.type !== "string") {
+    return false;
+  }
+  return value.type === "text" || value.type === "image" || value.type === "audio" || value.type === "resource";
+}
+
+// packages/tiny-stdio-mcp-server/src/server.ts
+var PROTOCOL_VERSION = "2025-11-25";
+function createServer(options) {
+  const tools = /* @__PURE__ */ new Map();
+  const notificationListeners = /* @__PURE__ */ new Set();
+  let initialized = false;
+  const handleMessage = async (method, params) => {
+    if (method === "ping") {
+      return { result: {} };
+    }
+    if (method === "initialize") {
+      initialized = true;
+      const requestedProtocol = typeof params?.protocolVersion === "string" ? params.protocolVersion : null;
+      const result = {
+        protocolVersion: requestedProtocol ?? PROTOCOL_VERSION,
+        capabilities: {
+          tools: {
+            listChanged: true
+          }
+        },
+        serverInfo: {
+          name: options.name,
+          version: options.version
+        }
+      };
+      return { result };
+    }
+    if (method === "notifications/initialized") {
+      return { result: void 0 };
+    }
+    if (!initialized) {
+      return {
+        error: {
+          code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
+          message: "Server not initialized"
+        }
+      };
+    }
+    if (method === "tools/list") {
+      const toolList = [];
+      for (const tool of tools.values()) {
+        toolList.push({
+          name: tool.name,
+          description: tool.description,
+          inputSchema: tool.inputSchema
+        });
+      }
+      return { result: { tools: toolList } };
+    }
+    if (method === "tools/call") {
+      const toolName = params?.name;
+      const toolArgs = params?.arguments || {};
+      if (!toolName) {
+        return {
+          error: {
+            code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+            message: "Tool name required"
+          }
+        };
+      }
+      const tool = tools.get(toolName);
+      if (!tool) {
+        return {
+          error: {
+            code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+            message: `Tool not found: ${toolName}`
+          }
+        };
+      }
+      try {
+        const handlerResult = await tool.handler(toolArgs);
+        const result = { content: toContentBlocks(handlerResult) };
+        return { result };
+      } catch (err) {
+        if (err instanceof ToolError) {
+          return {
+            error: {
+              code: err.code,
+              message: err.message
+            }
+          };
+        }
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        const result = {
+          content: [{ type: "text", text: `Error: ${errorMessage}` }],
+          isError: true
+        };
+        return { result };
+      }
+    }
+    return {
+      error: {
+        code: JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND,
+        message: "Method not found"
+      }
+    };
+  };
+  const processLine = async (line, write2) => {
+    const parsed = parseMessage(line);
+    if (!parsed.success) {
+      write2(formatErrorResponse(parsed.id, parsed.error) + "\n");
+      return;
+    }
+    const { request, isNotification } = parsed;
+    const { result, error } = await server.handleMessage(
+      request.method,
+      request.params
+    );
+    if (isNotification) {
+      return;
+    }
+    const requestWithId = request;
+    if (error) {
+      write2(formatErrorResponse(requestWithId.id, error) + "\n");
+    } else if (result !== void 0) {
+      write2(formatSuccessResponse(requestWithId.id, result) + "\n");
+    }
+  };
+  const broadcastNotification = (method) => {
+    const notification = {
+      jsonrpc: "2.0",
+      method
+    };
+    for (const listener of notificationListeners) {
+      listener(notification);
+    }
+  };
+  const server = {
+    tool(name, description, inputSchema, handler) {
+      tools.set(name, {
+        name,
+        description,
+        inputSchema,
+        handler
+      });
+      return server;
+    },
+    onNotification(listener) {
+      notificationListeners.add(listener);
+      return () => {
+        notificationListeners.delete(listener);
+      };
+    },
+    removeTool(name) {
+      return tools.delete(name);
+    },
+    async notifyToolsChanged() {
+      if (initialized) {
+        broadcastNotification("notifications/tools/list_changed");
+      }
+    },
+    handleMessage,
+    async listen() {
+      return server.connect({
+        readable: process.stdin,
+        writable: process.stdout
+      });
+    },
+    async connect(transport) {
+      return new Promise((resolve2) => {
+        const unsubscribe = server.onNotification((notification) => {
+          transport.writable.write(`${JSON.stringify(notification)}
+`);
+        });
+        const rl = readline.createInterface({
+          input: transport.readable,
+          crlfDelay: Infinity
+        });
+        rl.on("line", (line) => {
+          processLine(line, (data) => transport.writable.write(data));
+        });
+        rl.on("close", () => {
+          unsubscribe();
+          resolve2();
+        });
+      });
+    },
+    async connectSDK(transport) {
+      return new Promise((resolve2) => {
+        const unsubscribe = server.onNotification((notification) => {
+          void transport.send(notification);
+        });
+        transport.onmessage = async (message) => {
+          if (!("method" in message)) {
+            return;
+          }
+          if (!("id" in message) || message.id === void 0) {
+            await server.handleMessage(message.method, message.params);
+            return;
+          }
+          const request = message;
+          const { result, error } = await server.handleMessage(
+            request.method,
+            request.params
+          );
+          if (error) {
+            const response = {
+              jsonrpc: "2.0",
+              id: request.id,
+              error
+            };
+            await transport.send(response);
+          } else if (result !== void 0) {
+            const response = {
+              jsonrpc: "2.0",
+              id: request.id,
+              result
+            };
+            await transport.send(response);
+          }
+        };
+        transport.onclose = () => {
+          unsubscribe();
+          resolve2();
+        };
+        transport.start();
+      });
+    }
+  };
+  return server;
+}
+
+// packages/tiny-stdio-mcp-server/src/schema.ts
+function defineSchema(definition) {
+  const properties = {};
+  const required = [];
+  for (const [key, prop] of Object.entries(definition)) {
+    properties[key] = {
+      type: prop.type,
+      ...prop.description !== void 0 && { description: prop.description }
+    };
+    if (!prop.optional) {
+      required.push(key);
+    }
+  }
+  return {
+    type: "object",
+    properties,
+    required
+  };
+}
+
+// packages/memory/src/mcp.ts
+async function startMemoryMcpServer(opts) {
+  const server = createServer({
+    name: "poe-code-memory",
+    version: "0.0.1"
+  });
+  server.tool("list_pages", "List memory pages.", defineSchema({}), async () => ({
+    pages: (await listPages(opts.root)).map((page) => ({
+      rel_path: page.relPath,
+      description: page.frontmatter.description ?? ""
+    }))
+  }));
+  server.tool(
+    "read_page",
+    "Read a memory page.",
+    defineSchema({ rel_path: { type: "string" } }),
+    async ({ rel_path }) => {
+      const page = await readPage(opts.root, rel_path);
+      return {
+        rel_path: page.relPath,
+        frontmatter: page.frontmatter,
+        body: page.body,
+        bytes: page.bytes
+      };
+    }
+  );
+  server.tool(
+    "search_memory",
+    "Search memory pages.",
+    defineSchema({
+      query: { type: "string" },
+      limit: { type: "number", optional: true }
+    }),
+    async ({ query, limit }) => {
+      const hits = await searchMemory(opts.root, query);
+      return { hits: typeof limit === "number" ? hits.slice(0, limit) : hits };
+    }
+  );
+  server.tool("status", "Show memory status.", defineSchema({}), async () => statusOf(opts.root));
+  if (opts.allowWrites) {
+    server.tool(
+      "append_to_page",
+      "Append content to a memory page.",
+      defineSchema({
+        rel_path: { type: "string" },
+        content: { type: "string" },
+        reason: { type: "string" }
+      }),
+      async ({ rel_path, content, reason }) => ({
+        diff: await appendToPage(opts.root, rel_path, content, { reason })
+      })
+    );
+  }
+  return {
+    server,
+    stop: async () => {
+    }
+  };
+}
+function printMcpConfig() {
+  return JSON.stringify(
+    {
+      mcpServers: {
+        "poe-code-memory": {
+          type: "stdio",
+          command: "poe-code",
+          args: ["memory-mcp"]
+        }
+      }
+    },
+    null,
+    2
+  );
+}
+
+// packages/agent-skill-config/src/configs.ts
+import os from "node:os";
+import path21 from "node:path";
+
+// packages/agent-defs/src/agents/claude-code.ts
+var claudeCodeAgent = {
+  id: "claude-code",
+  name: "claude-code",
+  label: "Claude Code",
+  summary: "Configure Claude Code to route through Poe.",
+  aliases: ["claude"],
+  binaryName: "claude",
+  configPath: "~/.claude/settings.json",
+  branding: {
+    colors: {
+      dark: "#C15F3C",
+      light: "#C15F3C"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/claude-desktop.ts
+var claudeDesktopAgent = {
+  id: "claude-desktop",
+  name: "claude-desktop",
+  label: "Claude Desktop",
+  summary: "Anthropic's official desktop application for Claude",
+  configPath: "~/.claude/settings.json",
+  branding: {
+    colors: {
+      dark: "#D97757",
+      light: "#D97757"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/codex.ts
+var codexAgent = {
+  id: "codex",
+  name: "codex",
+  label: "Codex",
+  summary: "Configure Codex to use Poe as the model provider.",
+  binaryName: "codex",
+  configPath: "~/.codex/config.toml",
+  branding: {
+    colors: {
+      dark: "#D5D9DF",
+      light: "#7A7F86"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/opencode.ts
+var openCodeAgent = {
+  id: "opencode",
+  name: "opencode",
+  label: "OpenCode CLI",
+  summary: "Configure OpenCode CLI to use the Poe API.",
+  binaryName: "opencode",
+  configPath: "~/.config/opencode/config.json",
+  branding: {
+    colors: {
+      dark: "#4A4F55",
+      light: "#2F3338"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/kimi.ts
+var kimiAgent = {
+  id: "kimi",
+  name: "kimi",
+  label: "Kimi",
+  summary: "Configure Kimi CLI to use Poe API",
+  aliases: ["kimi-cli"],
+  binaryName: "kimi",
+  configPath: "~/.kimi/config.toml",
+  branding: {
+    colors: {
+      dark: "#7B68EE",
+      light: "#6A5ACD"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/goose.ts
+var gooseAgent = {
+  id: "goose",
+  name: "goose",
+  label: "Goose",
+  summary: "Block's open-source AI agent with ACP support.",
+  binaryName: "goose",
+  configPath: "~/.config/goose/config.yaml",
+  branding: {
+    colors: {
+      dark: "#FF6B35",
+      light: "#E85D26"
+    }
+  }
+};
+
+// packages/agent-defs/src/agents/poe-agent.ts
+var poeAgentAgent = {
+  id: "poe-agent",
+  name: "poe-agent",
+  label: "Poe Agent",
+  summary: "Run one-shot prompts with the built-in Poe agent runtime.",
+  configPath: "~/.poe-code/config.json",
+  branding: {
+    colors: {
+      dark: "#A465F7",
+      light: "#7A3FD3"
+    }
+  }
+};
+
+// packages/agent-defs/src/registry.ts
+var allAgents = [
+  claudeCodeAgent,
+  claudeDesktopAgent,
+  codexAgent,
+  openCodeAgent,
+  kimiAgent,
+  gooseAgent,
+  poeAgentAgent
+];
+var lookup = /* @__PURE__ */ new Map();
+for (const agent of allAgents) {
+  const values = [agent.id, agent.name, ...agent.aliases ?? []];
+  for (const value of values) {
+    const normalized = value.toLowerCase();
+    if (!lookup.has(normalized)) {
+      lookup.set(normalized, agent.id);
+    }
+  }
+}
+function resolveAgentId(input) {
+  if (!input) {
+    return void 0;
+  }
+  return lookup.get(input.toLowerCase());
+}
+
+// packages/agent-skill-config/src/configs.ts
+var agentSkillConfigs = {
+  "claude-code": {
+    globalSkillDir: "~/.claude/skills",
+    localSkillDir: ".claude/skills"
+  },
+  codex: {
+    globalSkillDir: "~/.codex/skills",
+    localSkillDir: ".codex/skills"
+  },
+  opencode: {
+    globalSkillDir: "~/.config/opencode/skills",
+    localSkillDir: ".opencode/skills"
+  },
+  goose: {
+    globalSkillDir: "~/.agents/skills",
+    localSkillDir: ".agents/skills"
+  }
+};
+var supportedAgents = Object.keys(agentSkillConfigs);
+function resolveAgentSupport(input, registry = agentSkillConfigs) {
+  const resolvedId = resolveAgentId(input);
+  if (!resolvedId) {
+    return { status: "unknown", input };
+  }
+  const config = registry[resolvedId];
+  if (!config) {
+    return { status: "unsupported", input, id: resolvedId };
+  }
+  return { status: "supported", input, id: resolvedId, config };
+}
+
+// packages/agent-skill-config/src/templates.ts
+import { readFile as readFile11, stat as stat5 } from "node:fs/promises";
+import path22 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// packages/agent-skill-config/src/apply.ts
+var UnsupportedAgentError = class extends Error {
+  constructor(agentId) {
+    super(`Unsupported agent: ${agentId}`);
+    this.name = "UnsupportedAgentError";
+  }
+};
+function toHomeRelative(localSkillDir) {
+  if (localSkillDir.startsWith("~/") || localSkillDir === "~") {
+    return localSkillDir;
+  }
+  const normalized = localSkillDir.startsWith("./") ? localSkillDir.slice(2) : localSkillDir;
+  return `~/${normalized}`;
+}
+var SKILL_TEMPLATE_ID = "__skill_content__";
+async function installSkill(agentId, skill, options) {
+  const support = resolveAgentSupport(agentId);
+  if (support.status !== "supported") {
+    throw new UnsupportedAgentError(agentId);
+  }
+  const scope = options.scope ?? "local";
+  const config = support.config;
+  const skillDir = scope === "global" ? config.globalSkillDir : toHomeRelative(config.localSkillDir);
+  const skillFolderPath = `${skillDir}/${skill.name}`;
+  const skillFilePath = `${skillFolderPath}/SKILL.md`;
+  const displayPath = `${scope === "global" ? config.globalSkillDir : config.localSkillDir}/${skill.name}/SKILL.md`;
+  await runMutations(
+    [
+      fileMutation.ensureDirectory({
+        path: skillFolderPath,
+        label: `Ensure skill directory ${skill.name}`
+      }),
+      templateMutation.write({
+        target: skillFilePath,
+        templateId: SKILL_TEMPLATE_ID,
+        label: `Write skill ${skill.name}`
+      })
+    ],
+    {
+      fs: options.fs,
+      homeDir: scope === "global" ? options.homeDir : options.cwd,
+      dryRun: options.dryRun,
+      observers: options.observers,
+      templates: async (templateId) => {
+        if (templateId === SKILL_TEMPLATE_ID) {
+          return skill.content;
+        }
+        throw new Error(`Unknown template: ${templateId}`);
+      }
+    }
+  );
+  return { skillPath: skillFilePath, displayPath };
+}
+
+// packages/agent-mcp-config/src/configs.ts
+var agentMcpConfigs = {
+  "claude-code": {
+    configFile: "~/.claude.json",
+    configKey: "mcpServers",
+    format: "json",
+    shape: "standard"
+  },
+  "claude-desktop": {
+    configFile: (platform) => {
+      switch (platform) {
+        case "darwin":
+          return "~/Library/Application Support/Claude/claude_desktop_config.json";
+        case "win32":
+          return "~/AppData/Roaming/Claude/claude_desktop_config.json";
+        default:
+          return "~/.config/Claude/claude_desktop_config.json";
+      }
+    },
+    configKey: "mcpServers",
+    format: "json",
+    shape: "standard",
+    mcpOutputFormat: "markdown_instructions"
+  },
+  codex: {
+    configFile: "~/.codex/config.toml",
+    configKey: "mcp_servers",
+    format: "toml",
+    shape: "standard"
+  },
+  opencode: {
+    configFile: "~/.config/opencode/opencode.json",
+    configKey: "mcp",
+    format: "json",
+    shape: "opencode"
+  },
+  kimi: {
+    configFile: "~/.kimi/mcp.json",
+    configKey: "mcpServers",
+    format: "json",
+    shape: "standard"
+  },
+  goose: {
+    configFile: "~/.config/goose/config.yaml",
+    configKey: "extensions",
+    format: "yaml",
+    shape: "goose"
+  }
+};
+var supportedAgents2 = Object.keys(agentMcpConfigs);
+function resolveAgentSupport2(input, registry = agentMcpConfigs) {
+  const resolvedId = resolveAgentId(input);
+  if (!resolvedId) {
+    return { status: "unknown", input };
+  }
+  const config = registry[resolvedId];
+  if (!config) {
+    return { status: "unsupported", input, id: resolvedId };
+  }
+  return { status: "supported", input, id: resolvedId, config };
+}
+function isSupported(agentId) {
+  return resolveAgentSupport2(agentId).status === "supported";
+}
+function getAgentConfig2(agentId) {
+  const support = resolveAgentSupport2(agentId);
+  return support.status === "supported" ? support.config : void 0;
+}
+function resolveConfigPath2(config, platform) {
+  if (typeof config.configFile === "function") {
+    return config.configFile(platform);
+  }
+  return config.configFile;
+}
+
+// packages/agent-mcp-config/src/apply.ts
+import path23 from "node:path";
+import { parse as parseYaml3, stringify as stringifyYaml2 } from "yaml";
+
+// packages/agent-mcp-config/src/shapes.ts
+function transformStdioServer(config, enabled) {
+  if (!enabled) {
+    return void 0;
+  }
+  const result = {
+    command: config.command
+  };
+  if (config.args && config.args.length > 0) {
+    result.args = config.args;
+  }
+  if (config.env && Object.keys(config.env).length > 0) {
+    result.env = config.env;
+  }
+  return result;
+}
+function standardShape(entry) {
+  const enabled = entry.enabled !== false;
+  if (entry.config.transport === "stdio") {
+    return transformStdioServer(entry.config, enabled);
+  }
+  if (!enabled) {
+    return void 0;
+  }
+  return {
+    command: entry.config.url
+  };
+}
+function transformStdioServerOpencode(config, enabled) {
+  const command = config.args && config.args.length > 0 ? [config.command, ...config.args] : [config.command];
+  const result = {
+    type: "local",
+    command,
+    enabled
+  };
+  if (config.env && Object.keys(config.env).length > 0) {
+    result.env = config.env;
+  }
+  return result;
+}
+function opencodeShape(entry) {
+  const enabled = entry.enabled !== false;
+  if (entry.config.transport === "stdio") {
+    return transformStdioServerOpencode(entry.config, enabled);
+  }
+  return {
+    type: "local",
+    command: [entry.config.url],
+    enabled
+  };
+}
+function gooseShape(entry) {
+  const enabled = entry.enabled !== false;
+  if (!enabled) {
+    return void 0;
+  }
+  if (entry.config.transport === "stdio") {
+    const result2 = {
+      type: "stdio",
+      cmd: entry.config.command
+    };
+    if (entry.config.args && entry.config.args.length > 0) {
+      result2.args = entry.config.args;
+    }
+    if (entry.config.env && Object.keys(entry.config.env).length > 0) {
+      result2.envs = entry.config.env;
+    }
+    return result2;
+  }
+  const result = {
+    type: "http",
+    url: entry.config.url
+  };
+  if (entry.config.headers && Object.keys(entry.config.headers).length > 0) {
+    result.headers = entry.config.headers;
+  }
+  return result;
+}
+var shapeTransformers = {
+  standard: standardShape,
+  opencode: opencodeShape,
+  goose: gooseShape
+};
+function getShapeTransformer(shape) {
+  return shapeTransformers[shape];
+}
+
+// packages/agent-mcp-config/src/apply.ts
+function getConfigDirectory(configPath) {
+  return path23.dirname(configPath);
+}
+var UnsupportedAgentError2 = class extends Error {
+  constructor(agentId) {
+    super(`Unsupported agent: ${agentId}`);
+    this.name = "UnsupportedAgentError";
+  }
+};
+function isConfigObject6(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function resolveServerMap(document, configKey) {
+  const value = document[configKey];
+  return isConfigObject6(value) ? value : {};
+}
+function mergeServerMap(document, configKey, servers) {
+  return { ...document, [configKey]: servers };
+}
+function expandHomePath(configPath, homeDir) {
+  if (!configPath.startsWith("~")) {
+    return configPath;
+  }
+  if (configPath === "~") {
+    return homeDir;
+  }
+  if (configPath.startsWith("~/")) {
+    return path23.join(homeDir, configPath.slice(2));
+  }
+  return path23.join(homeDir, configPath.slice(1));
+}
+function parseYamlDocument(content) {
+  if (content.trim() === "") {
+    return {};
+  }
+  const parsed = parseYaml3(content);
+  if (parsed === null || parsed === void 0) {
+    return {};
+  }
+  if (!isConfigObject6(parsed)) {
+    throw new Error("Expected YAML document to be an object.");
+  }
+  return parsed;
+}
+function serializeYamlDocument(document) {
+  const serialized = stringifyYaml2(document);
+  return serialized.endsWith("\n") ? serialized : `${serialized}
+`;
+}
+async function readYamlConfig(configPath, options) {
+  const absolutePath = expandHomePath(configPath, options.homeDir);
+  const existingContent = await readFileIfExists(options.fs, absolutePath);
+  if (existingContent === null) {
+    return {};
+  }
+  return parseYamlDocument(existingContent);
+}
+async function writeYamlConfig(configPath, document, options) {
+  if (options.dryRun) {
+    return;
+  }
+  const absolutePath = expandHomePath(configPath, options.homeDir);
+  const configDir = path23.dirname(absolutePath);
+  await options.fs.mkdir(configDir, { recursive: true });
+  await options.fs.writeFile(absolutePath, serializeYamlDocument(document), {
+    encoding: "utf8"
+  });
+}
+function removeServer(document, configKey, serverName) {
+  const servers = resolveServerMap(document, configKey);
+  if (!(serverName in servers)) {
+    return { changed: false, content: document };
+  }
+  const nextServers = { ...servers };
+  delete nextServers[serverName];
+  if (Object.keys(nextServers).length === 0) {
+    const nextDocument = { ...document };
+    delete nextDocument[configKey];
+    return { changed: true, content: nextDocument };
+  }
+  return {
+    changed: true,
+    content: mergeServerMap(document, configKey, nextServers)
+  };
+}
+async function configure2(agentId, server, options) {
+  if (!isSupported(agentId)) {
+    throw new UnsupportedAgentError2(agentId);
+  }
+  const config = getAgentConfig2(agentId);
+  const configPath = resolveConfigPath2(config, options.platform);
+  const shapeTransformer = getShapeTransformer(config.shape);
+  const shaped = shapeTransformer(server);
+  if (shaped === void 0) {
+    await unconfigure2(agentId, server.name, options);
+    return;
+  }
+  if (config.format === "yaml") {
+    const document = await readYamlConfig(configPath, options);
+    const servers = resolveServerMap(document, config.configKey);
+    const nextDocument = mergeServerMap(document, config.configKey, {
+      ...servers,
+      [server.name]: shaped
+    });
+    await writeYamlConfig(configPath, nextDocument, options);
+    return;
+  }
+  const configDir = getConfigDirectory(configPath);
+  await runMutations(
+    [
+      fileMutation.ensureDirectory({
+        path: configDir,
+        label: `Ensure directory ${configDir}`
+      }),
+      // Use transform to replace the server entry entirely (not deep-merge)
+      // This ensures old fields like 'args' are removed when switching to array 'command'
+      configMutation.transform({
+        target: configPath,
+        format: config.format,
+        transform: (document) => {
+          const servers = resolveServerMap(document, config.configKey);
+          const newServers = {
+            ...servers,
+            [server.name]: shaped
+          };
+          return {
+            changed: true,
+            content: mergeServerMap(document, config.configKey, newServers)
+          };
+        },
+        label: `Add ${server.name} to ${configPath}`
+      })
+    ],
+    {
+      fs: options.fs,
+      homeDir: options.homeDir,
+      dryRun: options.dryRun,
+      observers: options.observers
+    }
+  );
+}
+async function unconfigure2(agentId, serverName, options) {
+  if (!isSupported(agentId)) {
+    throw new UnsupportedAgentError2(agentId);
+  }
+  const config = getAgentConfig2(agentId);
+  const configPath = resolveConfigPath2(config, options.platform);
+  if (config.format === "yaml") {
+    const document = await readYamlConfig(configPath, options);
+    const { changed, content } = removeServer(
+      document,
+      config.configKey,
+      serverName
+    );
+    if (!changed) {
+      return;
+    }
+    await writeYamlConfig(configPath, content, options);
+    return;
+  }
+  await runMutations(
+    [
+      configMutation.prune({
+        target: configPath,
+        format: config.format,
+        shape: {
+          [config.configKey]: {
+            [serverName]: {}
+          }
+        },
+        label: `Remove ${serverName} from ${configPath}`
+      })
+    ],
+    {
+      fs: options.fs,
+      homeDir: options.homeDir,
+      dryRun: options.dryRun,
+      observers: options.observers
+    }
+  );
+}
+
+// packages/memory/src/install.ts
+var SKILL_NAME = "poe-code-memory";
+async function installMemory(options) {
+  if (options.skillOnly && options.mcpOnly) {
+    throw new Error("--skill-only and --mcp-only cannot be combined.");
+  }
+  const scope = options.scope ?? "local";
+  let skillPath;
+  if (!options.mcpOnly) {
+    const installed = await installSkill(
+      options.agent,
+      {
+        name: SKILL_NAME,
+        content: options.skillContent
+      },
+      {
+        fs: options.fs,
+        cwd: options.cwd,
+        homeDir: options.homeDir,
+        scope,
+        dryRun: options.dryRun,
+        observers: options.observers
+      }
+    );
+    skillPath = installed.displayPath;
+  }
+  let mcpConfigPath;
+  if (!options.skillOnly) {
+    await configure2(
+      options.agent,
+      {
+        name: SKILL_NAME,
+        config: {
+          transport: "stdio",
+          command: "poe-code",
+          args: options.allowWrites ? ["memory-mcp", "--allow-writes"] : ["memory-mcp"]
+        }
+      },
+      {
+        fs: options.fs,
+        homeDir: options.homeDir,
+        platform: options.platform,
+        dryRun: options.dryRun,
+        observers: options.observers
+      }
+    );
+    mcpConfigPath = options.agent === "codex" ? `${options.homeDir}/.config/codex/mcp-config.json` : `${options.homeDir}/.mcp.json`;
+  }
+  return {
+    skillInstalled: !options.mcpOnly,
+    mcpConfigured: !options.skillOnly,
+    skillPath,
+    mcpConfigPath
+  };
+}
+
+// packages/memory/src/query.ts
+import * as fs12 from "node:fs/promises";
+import path24 from "node:path";
+async function queryMemory(root, options) {
+  const pages = await listPages(root);
+  if (pages.length === 0) {
+    return {
+      answer: "",
+      citations: [],
+      tokensUsed: 0,
+      budget: options.budget,
+      exitCode: 0
+    };
+  }
+  const configOptions = {
+    fs: fs12,
+    filePath: path24.join(inferRepoRoot2(root), "poe-code.json")
+  };
+  const agentId = await resolveAgent(configOptions, options.agent ?? null) ?? options.agent ?? "claude-code";
+  const context = await selectQueryContext(root, options.question, options.budget);
+  const spawnFn = options.spawnFn;
+  const result = await spawnFn?.(agentId, context.prompt) ?? {
+    answer: "",
+    citations: [],
+    tokensUsed: context.tokensUsed,
+    budget: options.budget,
+    exitCode: 0
+  };
+  return {
+    answer: result.answer,
+    citations: result.citations,
+    tokensUsed: result.tokensUsed,
+    budget: options.budget,
+    exitCode: result.exitCode
+  };
+}
+async function selectQueryContext(root, question, budget) {
+  const [indexText, pages] = await Promise.all([
+    fs12.readFile(path24.join(root, MEMORY_INDEX_RELPATH), "utf8"),
+    listPages(root)
+  ]);
+  const indexTokens = countTokens(indexText);
+  if (indexTokens > budget) {
+    throw new Error(`budget too small; needs at least ${indexTokens} tokens`);
+  }
+  const rankedPages = rankPagesForQuery(pages, question);
+  const selectedPages = [];
+  let tokensUsed = indexTokens;
+  let truncated = false;
+  for (const page of rankedPages) {
+    const pageTokens = countTokens(renderPageContext(page));
+    if (tokensUsed + pageTokens > budget) {
+      truncated = true;
+      continue;
+    }
+    selectedPages.push(page);
+    tokensUsed += pageTokens;
+  }
+  return {
+    prompt: buildQueryPrompt(question, indexText, selectedPages),
+    selectedPages,
+    tokensUsed,
+    truncated
+  };
+}
+function rankPagesForQuery(pages, question) {
+  const terms = tokenize(question);
+  const documents = pages.map((page) => {
+    const text = [page.relPath, page.frontmatter.name ?? "", page.frontmatter.description ?? "", page.body].join("\n").toLowerCase();
+    const tokens = tokenize(text);
+    const counts = /* @__PURE__ */ new Map();
+    for (const token of tokens) {
+      counts.set(token, (counts.get(token) ?? 0) + 1);
+    }
+    return { page, counts, size: tokens.length };
+  });
+  const docFrequency = /* @__PURE__ */ new Map();
+  for (const term of terms) {
+    let count = 0;
+    for (const document of documents) {
+      if ((document.counts.get(term) ?? 0) > 0) {
+        count += 1;
+      }
+    }
+    docFrequency.set(term, count);
+  }
+  return documents.map((document) => ({
+    page: document.page,
+    score: terms.reduce((total, term) => {
+      const tf = (document.counts.get(term) ?? 0) / Math.max(document.size, 1);
+      const idf = Math.log((documents.length + 1) / ((docFrequency.get(term) ?? 0) + 1)) + 1;
+      return total + tf * idf;
+    }, 0)
+  })).sort((left, right) => right.score - left.score || left.page.relPath.localeCompare(right.page.relPath)).map((entry) => entry.page);
+}
+function buildQueryPrompt(question, indexText, pages) {
+  const renderedPages = pages.map((page) => renderPageContext(page)).join("\n\n");
+  return [
+    "Answer using only the provided memory pages.",
+    "Cite pages and sections with [rel_path \xA7section]. If memory does not answer the question, say so.",
+    "No tools are available.",
+    "",
+    `Question: ${question}`,
+    "",
+    "INDEX.md",
+    indexText,
+    "",
+    renderedPages
+  ].join("\n");
+}
+function renderPageContext(page) {
+  return [`FILE: ${page.relPath}`, page.body].join("\n");
+}
+function tokenize(text) {
+  return text.toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length > 0);
+}
+function inferRepoRoot2(root) {
+  return path24.resolve(root, "..", "..");
+}
+
+// packages/memory/src/explain.ts
+async function explainPage(root, options) {
+  const targetPage = await readPageIfPresent(root, options.relPath);
+  if (targetPage === void 0) {
+    return {
+      answer: "",
+      citations: [],
+      tokensUsed: 0,
+      budget: options.budget,
+      exitCode: 0,
+      inboundPages: [],
+      outboundSources: []
+    };
+  }
+  const allContext = await selectQueryContext(root, options.relPath, Number.MAX_SAFE_INTEGER);
+  const relatedPages = collectRelatedPages(allContext.selectedPages, targetPage.relPath, targetPage.frontmatter.sources ?? []);
+  const prompt = buildExplainPrompt(targetPage.relPath, relatedPages);
+  const tokensUsed = countTokens(prompt);
+  if (tokensUsed > options.budget) {
+    throw new Error(`budget too small; needs at least ${tokensUsed} tokens`);
+  }
+  const spawnFn = options.spawnFn;
+  const response = await queryMemory(root, {
+    question: `explain ${options.relPath}`,
+    budget: options.budget,
+    agent: options.agent,
+    spawnFn: spawnFn === void 0 ? void 0 : async (...args) => {
+      const [agent] = args;
+      return spawnFn(agent, prompt);
+    }
+  });
+  return {
+    ...response,
+    inboundPages: relatedPages.filter((page) => page.relPath !== targetPage.relPath).filter((page) => (page.frontmatter.sources ?? []).some((source) => source.path === targetPage.relPath)).map((page) => page.relPath),
+    outboundSources: targetPage.frontmatter.sources ?? []
+  };
+}
+function collectRelatedPages(pages, targetRelPath, outboundSources) {
+  const memorySourcePaths = new Set(outboundSources.map((source) => source.path));
+  return pages.filter((page) => {
+    if (page.relPath === targetRelPath) {
+      return true;
+    }
+    if (memorySourcePaths.has(page.relPath)) {
+      return true;
+    }
+    return (page.frontmatter.sources ?? []).some((source) => source.path === targetRelPath);
+  });
+}
+function buildExplainPrompt(targetRelPath, pages) {
+  return [
+    "Summarize the target page using only the provided memory pages.",
+    "Return a 1-2 paragraph explanation plus the important inbound/outbound links.",
+    "Cite pages and sections with [rel_path \xA7section]. If memory is insufficient, say so.",
+    "No tools are available.",
+    "",
+    `Target page: ${targetRelPath}`,
+    "",
+    ...pages.map((page) => [`FILE: ${page.relPath}`, page.body].join("\n"))
+  ].join("\n\n");
+}
+async function readPageIfPresent(root, relPath) {
+  try {
+    return await readPage(root, relPath);
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+}
+
+// packages/memory/src/explain.cli.ts
+async function runMemoryExplain(input) {
+  return explainPage(input.root, {
+    relPath: input.relPath,
+    budget: input.budget,
+    agent: input.agent,
+    spawnFn: input.spawnFn
+  });
+}
+export {
+  INGEST_PROMPT_VERSION,
+  MEMORY_ROOT_ENV_VAR,
+  appendToPage,
+  auditClaims,
+  clearCache,
+  clearMemory,
+  computeIngestKey,
+  computeTokenStats,
+  editPage,
+  explainPage,
+  ingest,
+  initMemory,
+  installMemory,
+  listPages,
+  parseClaims,
+  printMcpConfig,
+  queryMemory,
+  rankPagesForQuery,
+  readCacheEntry,
+  readPage,
+  reconcile,
+  resolveConfiguredMemoryRoot,
+  resolveMemoryRoot,
+  runMemoryCacheClear,
+  runMemoryCacheStatus,
+  runMemoryExplain,
+  searchMemory,
+  selectQueryContext,
+  serializeTag,
+  snapshot,
+  startMemoryMcpServer,
+  statusOf,
+  writeCacheEntry,
+  writePage
+};
+//# sourceMappingURL=index.js.map