@cleocode/caamp 2026.9.7 → 2026.9.9

package/dist/{chunk-6KBUDJZI.js → chunk-52ZWZXEN.js}

@@ -7,7 +7,7 @@ import {
   parseBlocks,
   reconcile,
   withFileLock
-} from "./chunk-3IQUGSIV.js";
+} from "./chunk-G3CEXEW2.js";
 import {
   __export,
   getAgentsConfigPath,
@@ -4699,4 +4699,4 @@ export {
   discoverSkillsMulti,
   validateSkill
 };
-//# sourceMappingURL=chunk-6KBUDJZI.js.map
+//# sourceMappingURL=chunk-52ZWZXEN.js.map

package/dist/{chunk-3IQUGSIV.js → chunk-G3CEXEW2.js}

@@ -7,9 +7,9 @@ import {
 
 // src/core/instructions/injector.ts
 import { existsSync } from "fs";
-import { readFile as readFile2, stat as stat2 } from "fs/promises";
-import { homedir } from "os";
-import { join as join2 } from "path";
+import { readFile as readFile3, stat as stat3 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname4, join as join2 } from "path";
 import { writeFileAtomic } from "@cleocode/core/tools/fs.js";
 
 // src/core/fs/atomic.ts
@@ -19,7 +19,7 @@ var DEFAULT_STALE_LOCK_MS = 3e4;
 var DEFAULT_LOCK_RETRIES = 400;
 var DEFAULT_LOCK_DELAY_MS = 25;
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 async function removeStaleGuard(guardPath, staleMs, expectedToken) {
   try {
@@ -363,13 +363,17 @@ function blockPattern() {
 function normalizeMarkers(content) {
   let repaired = 0;
   const heal = (input, source, canonical) => input.replace(new RegExp(source, "gmi"), (match) => {
-    if (match === canonical) return match;
+    const leading = /^[ \t\r]*/.exec(match)?.[0] ?? "";
+    const trailing = /[ \t\r]*$/.exec(match)?.[0] ?? "";
+    const replacement = leading + canonical + trailing;
+    if (match === replacement) return match;
     repaired += 1;
-    return canonical;
+    return replacement;
   });
-  let out = heal(content, CAAMP_DAMAGED_START_PATTERN_SOURCE, CAAMP_MARKER_START);
+  const bom = content.startsWith("\uFEFF") ? "\uFEFF" : "";
+  let out = heal(content.slice(bom.length), CAAMP_DAMAGED_START_PATTERN_SOURCE, CAAMP_MARKER_START);
   out = heal(out, CAAMP_DAMAGED_END_PATTERN_SOURCE, CAAMP_MARKER_END);
-  return { content: out, repaired };
+  return { content: bom + out, repaired };
 }
 function parseBlocks(fileContent) {
   const blocks = [];
@@ -390,24 +394,40 @@ function buildBlock(content) {
 ${content}
 ${CAAMP_MARKER_END}`;
 }
-function tidy(content) {
-  const collapsed = content.replace(/\n{3,}/g, "\n\n").trimEnd();
-  return collapsed.length > 0 ? `${collapsed}
-` : "";
+function assertBalancedMarkers(content) {
+  let open2 = false;
+  const markers = new RegExp(`${CAAMP_MARKER_START}|${CAAMP_MARKER_END}`, "g");
+  for (const match of content.matchAll(markers)) {
+    const opening = match[0] === CAAMP_MARKER_START;
+    if (opening === open2) {
+      throw new Error(
+        "Ambiguous CAAMP markers: nested or unmatched delimiter; original content preserved."
+      );
+    }
+    open2 = opening;
+  }
+  if (open2)
+    throw new Error(
+      "Ambiguous CAAMP markers: opening delimiter has no end; original content preserved."
+    );
 }
 function reconcile(existing, desiredContent, insert = "prepend") {
   const { content: healed, repaired } = normalizeMarkers(existing);
+  assertBalancedMarkers(healed);
   const blocks = parseBlocks(healed);
   const desiredBlock = buildBlock(desiredContent.trim());
+  assertBalancedMarkers(desiredBlock);
   if (blocks.length === 0) {
-    const body = healed.trim();
-    if (body.length === 0) return { content: tidy(desiredBlock), blocksBefore: 0, repaired };
+    if (healed.length === 0) return { content: `${desiredBlock}
+`, blocksBefore: 0, repaired };
+    const bom = healed.startsWith("\uFEFF") ? "\uFEFF" : "";
     return {
-      content: insert === "append" ? tidy(`${body}
+      content: insert === "append" ? `${healed}
 
-${desiredBlock}`) : tidy(`${desiredBlock}
+${desiredBlock}
+` : `${bom}${desiredBlock}
 
-${body}`),
+${healed.slice(bom.length)}`,
       blocksBefore: 0,
       repaired
     };
@@ -420,7 +440,7 @@ ${body}`),
     if (index === 0) out += desiredBlock;
   }
   out += healed.slice(cursor);
-  return { content: tidy(out), blocksBefore: blocks.length, repaired };
+  return { content: out, blocksBefore: blocks.length, repaired };
 }
 function mergeBlockBodies(blocks) {
   const seen = /* @__PURE__ */ new Set();
@@ -437,6 +457,7 @@ function mergeBlockBodies(blocks) {
 }
 function repairContent(existing) {
   const { content: healed, repaired } = normalizeMarkers(existing);
+  assertBalancedMarkers(healed);
   const blocks = parseBlocks(healed);
   if (blocks.length === 0) {
     return { content: healed, blocksBefore: 0, repaired };
@@ -446,6 +467,10 @@ function repairContent(existing) {
 }
 
 // src/core/instructions/templates.ts
+import { createHash } from "crypto";
+import { readFile as readFile2, realpath, stat as stat2 } from "fs/promises";
+import { homedir } from "os";
+import { dirname as dirname3, resolve } from "path";
 function buildInjectionContent(template) {
   const lines = [];
   for (const ref of template.references) {
@@ -512,6 +537,113 @@ function groupByInstructFile(providers) {
   }
   return groups;
 }
+async function resolveInstructionDelivery(content, baseDir) {
+  const result = {
+    content: "",
+    sources: [],
+    findings: [],
+    liveEvaluation: "unverified"
+  };
+  const visited = /* @__PURE__ */ new Set();
+  let bytes = 0;
+  async function expand(text, directory, ancestors) {
+    const lines = [];
+    let fence = null;
+    for (const line of text.split("\n")) {
+      const fenceMatch = /^\s*(`{3,}|~{3,})/.exec(line);
+      if (fenceMatch?.[1]) {
+        if (!fence) fence = fenceMatch[1];
+        else if (fenceMatch[1][0] === fence[0] && fenceMatch[1].length >= fence.length)
+          fence = null;
+        lines.push(line);
+        continue;
+      }
+      const stamp = !fence ? /^<!-- CAAMP:SOURCE (\S+) ([a-f0-9]{64}) -->$/.exec(line) : null;
+      if (stamp?.[1] && stamp[2]) {
+        let sourcePath = stamp[1];
+        try {
+          sourcePath = decodeURIComponent(sourcePath);
+          const sourceSize = (await stat2(sourcePath)).size;
+          bytes += sourceSize;
+          if (bytes > 524288) {
+            result.findings.push({
+              kind: "limit",
+              path: sourcePath,
+              reason: "Instruction byte budget exceeded."
+            });
+          } else {
+            const digest = createHash("sha256").update(await readFile2(sourcePath)).digest("hex");
+            if (digest !== stamp[2])
+              result.findings.push({
+                kind: "stale",
+                path: sourcePath,
+                reason: "Embedded source changed after delivery."
+              });
+          }
+        } catch (error) {
+          result.findings.push({
+            kind: "missing-reference",
+            path: sourcePath,
+            reason: String(error)
+          });
+        }
+        lines.push(line);
+        continue;
+      }
+      const ref = !fence ? /^\s*@([^\s]+)\s*$/.exec(line)?.[1] : void 0;
+      if (!ref) {
+        if (!/^\s*<!-- CAAMP:(START|END) -->\s*$/.test(line)) lines.push(line);
+        continue;
+      }
+      let path = resolve(directory, ref.startsWith("~/") ? resolve(homedir(), ref.slice(2)) : ref);
+      try {
+        path = await realpath(path);
+      } catch (error) {
+        result.findings.push({ kind: "missing-reference", path, reason: String(error) });
+        continue;
+      }
+      if (ancestors.includes(path)) {
+        result.findings.push({ kind: "cycle", path, reason: "Reference repeats an ancestor." });
+        continue;
+      }
+      if (visited.has(path)) {
+        result.findings.push({ kind: "duplicate", path, reason: "Source already embedded once." });
+        continue;
+      }
+      if (ancestors.length >= 16 || visited.size >= 64 || bytes >= 524288) {
+        result.findings.push({
+          kind: "limit",
+          path,
+          reason: "Instruction expansion budget exceeded."
+        });
+        continue;
+      }
+      try {
+        bytes += (await stat2(path)).size;
+        if (bytes > 524288) {
+          result.findings.push({
+            kind: "limit",
+            path,
+            reason: "Instruction byte budget exceeded."
+          });
+          continue;
+        }
+        const source = await readFile2(path, "utf8");
+        visited.add(path);
+        result.sources.push(path);
+        lines.push(
+          `<!-- CAAMP:SOURCE ${encodeURIComponent(path)} ${createHash("sha256").update(source).digest("hex")} -->`
+        );
+        lines.push(await expand(source, dirname3(path), [...ancestors, path]));
+      } catch (error) {
+        result.findings.push({ kind: "missing-reference", path, reason: String(error) });
+      }
+    }
+    return lines.join("\n");
+  }
+  result.content = await expand(content, baseDir, []);
+  return result;
+}
 
 // src/core/instructions/injector.ts
 function parseCaampBlocks(fileContent) {
@@ -522,8 +654,9 @@ async function dedupeFile(filePath) {
     return { filePath, removed: 0, kept: 0, modified: false, repaired: 0 };
   }
   return withFileLock(filePath, async () => {
-    const original = await readFile2(filePath, "utf-8");
+    const original = await readFile3(filePath, "utf-8");
     const { content: healed, repaired } = normalizeMarkers(original);
+    assertBalancedMarkers(healed);
     const blocks = parseBlocks(healed);
     if (blocks.length === 0) {
       if (repaired > 0 && healed !== original) {
@@ -548,8 +681,6 @@ async function dedupeFile(filePath) {
       }
     }
     result += healed.slice(cursor);
-    result = `${result.replace(/\n{3,}/g, "\n\n").trimEnd()}
-`;
     if (removed === 0 && repaired === 0) {
       return { filePath, removed: 0, kept: blocks.length, modified: false, repaired };
     }
@@ -585,7 +716,7 @@ async function repairInstructionFiles(projectDir, providers) {
   for (const filePath of paths) {
     files.push(
       await withFileLock(filePath, async () => {
-        const original = await readFile2(filePath, "utf-8");
+        const original = await readFile3(filePath, "utf-8");
         const { content, blocksBefore, repaired } = repairContent(original);
         const removed = Math.max(0, blocksBefore - 1);
         if (removed === 0 && repaired === 0) {
@@ -614,7 +745,7 @@ async function repairInstructionFiles(projectDir, providers) {
 }
 async function checkInjection(filePath, expectedContent) {
   if (!existsSync(filePath)) return "missing";
-  const raw = await readFile2(filePath, "utf-8");
+  const raw = await readFile3(filePath, "utf-8");
   const { content, repaired } = normalizeMarkers(raw);
   const blocks = parseBlocks(content);
   if (blocks.length === 0) return "none";
@@ -626,17 +757,16 @@ async function checkInjection(filePath, expectedContent) {
 }
 async function inject(filePath, content) {
   const body = content.trim();
-  if (!existsSync(filePath)) {
-    return withFileLock(filePath, async () => {
+  assertBalancedMarkers(buildBlock(body));
+  return withFileLock(filePath, async () => {
+    if (!existsSync(filePath)) {
       await writeFileAtomic({ path: filePath, content: `${buildBlock(body)}
 ` });
       return "created";
-    });
-  }
-  return withFileLock(filePath, async () => {
-    const existing = await readFile2(filePath, "utf-8");
+    }
+    const existing = await readFile3(filePath, "utf-8");
     if (existing.length === 0) {
-      assertNotTornRead(filePath, existing, (await stat2(filePath)).size);
+      assertNotTornRead(filePath, existing, (await stat3(filePath)).size);
     }
     const { content: next, blocksBefore, repaired } = reconcile(existing, body);
     if (next === existing) return "intact";
@@ -650,16 +780,16 @@ async function inject(filePath, content) {
 async function removeInjection(filePath) {
   if (!existsSync(filePath)) return false;
   return withFileLock(filePath, async () => {
-    const original = await readFile2(filePath, "utf-8");
+    const original = await readFile3(filePath, "utf-8");
     const { content } = normalizeMarkers(original);
+    assertBalancedMarkers(content);
     if (parseBlocks(content).length === 0) return false;
-    const cleaned = content.replace(blockPattern(), "").replace(/^\n{2,}/, "\n").trim();
+    const cleaned = content.replace(blockPattern(), "");
     if (!cleaned) {
       const { rm: rm2 } = await import("fs/promises");
       await rm2(filePath);
     } else {
-      await writeFileAtomic({ path: filePath, content: `${cleaned}
-` });
+      await writeFileAtomic({ path: filePath, content: cleaned });
     }
     return true;
   });
@@ -671,8 +801,26 @@ async function checkAllInjections(providers, projectDir, scope, expectedContent)
     const filePath = scope === "global" ? join2(provider.pathGlobal, provider.instructFile) : join2(projectDir, provider.instructFile);
     if (checked.has(filePath)) continue;
     checked.add(filePath);
-    const status = await checkInjection(filePath, expectedContent);
+    let status = await checkInjection(filePath, expectedContent);
+    const delivery = await resolveInstructionDelivery(`@${filePath}`, dirname4(filePath));
+    if (expectedContent !== void 0 && status === "outdated") {
+      delivery.findings.push({
+        kind: "stale",
+        path: filePath,
+        reason: "Managed content differs from the expected version."
+      });
+    }
+    if (existsSync(filePath) && parseBlocks(await readFile3(filePath, "utf8")).length > 1) {
+      delivery.findings.push({
+        kind: "duplicate",
+        path: filePath,
+        reason: "Multiple managed blocks are delivered."
+      });
+    }
+    if (delivery.findings.length > 0 && status === "current") status = "outdated";
     results.push({
+      deliveryFindings: delivery.findings,
+      liveEvaluation: delivery.liveEvaluation,
       file: filePath,
       provider: provider.id,
       status,
@@ -700,12 +848,30 @@ async function ensureProviderInstructionFile(providerId, projectDir, options) {
   }
   const scope = options.scope ?? "project";
   const filePath = scope === "global" ? join2(provider.pathGlobal, provider.instructFile) : join2(projectDir, provider.instructFile);
-  const references = options.references ?? getProviderInstructionReferences(providerId);
+  let references = options.references ?? getProviderInstructionReferences(providerId);
+  let content = options.content;
+  if (options.delivery !== "verified-references" && references.includes("@.cleo/memory-bridge.md") && !existsSync(join2(dirname4(filePath), ".cleo", "memory-bridge.md"))) {
+    references = references.filter((reference) => reference !== "@.cleo/memory-bridge.md");
+    content = [
+      ...content ?? [],
+      "Project memory bridge unavailable. Run `cleo memory digest` to inspect current evidence."
+    ];
+  }
   const template = {
     references,
-    content: options.content
+    content
   };
-  const injectionContent = buildInjectionContent(template);
+  let injectionContent = buildInjectionContent(template);
+  if (options.delivery !== "verified-references") {
+    const delivery = await resolveInstructionDelivery(injectionContent, dirname4(filePath));
+    const failures = delivery.findings.filter((finding) => finding.kind !== "duplicate");
+    if (failures.length > 0) {
+      throw new Error(
+        `Instruction delivery failed: ${failures.map((finding) => `${finding.kind}: ${finding.path}`).join("; ")}`
+      );
+    }
+    injectionContent = delivery.content;
+  }
   const action = await inject(filePath, injectionContent);
   return {
     filePath,
@@ -743,7 +909,7 @@ async function ensureAllProviderInstructionFiles(providerIds, projectDir, option
   return results;
 }
 function getProviderAgentFolder(providerId) {
-  const home = homedir();
+  const home = homedir2();
   switch (providerId) {
     case "claude-code":
     case "claude-sdk":
@@ -828,6 +994,7 @@ export {
   generateInjectionContent,
   generateSkillsSection,
   groupByInstructFile,
+  resolveInstructionDelivery,
   parseCaampBlocks,
   dedupeFile,
   dedupeFiles,
@@ -843,4 +1010,4 @@ export {
   getProviderAgentFolder,
   writeAgentFileToAllProviders
 };
-//# sourceMappingURL=chunk-3IQUGSIV.js.map
+//# sourceMappingURL=chunk-G3CEXEW2.js.map