@remnic/plugin-openclaw 1.0.34 → 1.0.36

package/dist/{chunk-7NMHI4IC.js → chunk-BLC3RQNV.js}

@@ -1,17 +1,17 @@
 import {
   external_exports
-} from "./chunk-EXDYWXMB.js";
+} from "./chunk-4XDQ3KEC.js";
 import {
   StorageManager,
   parseContinuityImprovementLoops,
   sanitizeMemoryContent
-} from "./chunk-ZXLYEVOP.js";
+} from "./chunk-G3CZA4SD.js";
 import {
   log
 } from "./chunk-UFU5GGGA.js";
 import {
   expandTildePath
-} from "./chunk-TDRJVMUP.js";
+} from "./chunk-EH4AXGRO.js";
 
 // ../remnic-core/src/compounding/engine.ts
 import { createHash } from "crypto";
@@ -48,558 +48,9 @@ var SharedFeedbackEntrySchema = external_exports.object({
   evidenceWindowEnd: external_exports.string().min(8).optional(),
   refs: external_exports.array(external_exports.string()).optional()
 });
-function safeSlug(s) {
-  let slug = s.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-  let start = 0;
-  while (start < slug.length && slug[start] === "-") start++;
-  let end = slug.length;
-  while (end > start && slug[end - 1] === "-") end--;
-  return slug.slice(start, end).slice(0, 80) || "output";
-}
-function ymd(d) {
-  return d.toISOString().slice(0, 10);
-}
-var CROSS_SIGNAL_STOPWORDS = /* @__PURE__ */ new Set([
-  "a",
-  "an",
-  "and",
-  "are",
-  "as",
-  "at",
-  "be",
-  "by",
-  "for",
-  "from",
-  "has",
-  "have",
-  "in",
-  "is",
-  "it",
-  "of",
-  "on",
-  "or",
-  "that",
-  "the",
-  "this",
-  "to",
-  "was",
-  "were",
-  "with",
-  "agent",
-  "output",
-  "today",
-  "daily",
-  "notes",
-  "note",
-  "summary"
-]);
-function extractTopicTokens(text, maxTokens = 12) {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  const tokens = text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).map((token) => token.trim()).filter((token) => token.length >= 4).filter((token) => !CROSS_SIGNAL_STOPWORDS.has(token));
-  for (const token of tokens) {
-    if (seen.has(token)) continue;
-    seen.add(token);
-    out.push(token);
-    if (out.length >= maxTokens) break;
-  }
-  return out;
-}
-function stripYamlFrontmatter(text) {
-  if (!text.startsWith("---\n")) return text;
-  const closing = text.indexOf("\n---\n", 4);
-  if (closing === -1) return text;
-  return text.slice(closing + 5);
-}
-function semanticRoot(token) {
-  let root = token.toLowerCase();
-  if (root.endsWith("izations") && root.length > 9) {
-    root = `${root.slice(0, -8)}ize`;
-  } else if (root.endsWith("ization") && root.length > 8) {
-    root = `${root.slice(0, -7)}ize`;
-  } else if (root.endsWith("isations") && root.length > 9) {
-    root = `${root.slice(0, -8)}ise`;
-  } else if (root.endsWith("isation") && root.length > 8) {
-    root = `${root.slice(0, -7)}ise`;
-  } else {
-    const suffixes = [
-      "ations",
-      "ation",
-      "ments",
-      "ment",
-      "ingly",
-      "edly",
-      "ings",
-      "ing",
-      "ers",
-      "er",
-      "ies",
-      "ied",
-      "ions",
-      "ion",
-      "es",
-      "ed",
-      "s"
-    ];
-    for (const suffix of suffixes) {
-      if (root.length > suffix.length + 3 && root.endsWith(suffix)) {
-        root = root.slice(0, -suffix.length);
-        break;
-      }
-    }
-  }
-  if (root.length > 4 && root.endsWith("e")) {
-    root = root.slice(0, -1);
-  }
-  return root;
-}
-function mergeOverlaps(base, extra) {
-  const merged = /* @__PURE__ */ new Map();
-  for (const entry of [...base, ...extra]) {
-    const existing = merged.get(entry.token);
-    if (existing) {
-      for (const agent of entry.agents) existing.agents.add(agent);
-      for (const sourcePath of entry.sourcePaths) existing.sourcePaths.add(sourcePath);
-    } else {
-      merged.set(entry.token, {
-        agents: new Set(entry.agents),
-        sourcePaths: new Set(entry.sourcePaths)
-      });
-    }
-  }
-  return [...merged.entries()].map(([token, value]) => ({
-    token,
-    agents: [...value.agents].sort(),
-    sourcePaths: [...value.sourcePaths].sort(),
-    agentCount: value.agents.size
-  })).filter((entry) => entry.agentCount >= 2).sort((a, b) => b.agentCount - a.agentCount || a.token.localeCompare(b.token));
-}
-async function computeSemanticOverlapCandidates(sources, maxCandidates, timeoutAtMs) {
-  const tokenRows = [];
-  for (const source of sources) {
-    for (const token of source.topics) {
-      if (Date.now() >= timeoutAtMs) return { overlaps: [], candidateCount: tokenRows.length, timedOut: true };
-      await new Promise((resolve) => setImmediate(resolve));
-      tokenRows.push({ token, agent: source.agent, path: source.path });
-      if (tokenRows.length >= maxCandidates) break;
-    }
-    if (tokenRows.length >= maxCandidates) break;
-  }
-  const byRoot = /* @__PURE__ */ new Map();
-  for (const row of tokenRows) {
-    if (Date.now() >= timeoutAtMs) return { overlaps: [], candidateCount: tokenRows.length, timedOut: true };
-    await new Promise((resolve) => setImmediate(resolve));
-    const root = semanticRoot(row.token);
-    if (root.length < 4) continue;
-    const rootGroup = byRoot.get(root) ?? /* @__PURE__ */ new Map();
-    const tokenGroup = rootGroup.get(row.token) ?? { agents: /* @__PURE__ */ new Set(), paths: /* @__PURE__ */ new Set() };
-    tokenGroup.agents.add(row.agent);
-    tokenGroup.paths.add(row.path);
-    rootGroup.set(row.token, tokenGroup);
-    byRoot.set(root, rootGroup);
-  }
-  const overlaps = [];
-  for (const [root, tokenMap] of byRoot.entries()) {
-    if (Date.now() >= timeoutAtMs) return { overlaps: [], candidateCount: tokenRows.length, timedOut: true };
-    await new Promise((resolve) => setImmediate(resolve));
-    if (tokenMap.size < 2) continue;
-    const agents = /* @__PURE__ */ new Set();
-    const sourcePaths = /* @__PURE__ */ new Set();
-    for (const value of tokenMap.values()) {
-      for (const agent of value.agents) agents.add(agent);
-      for (const sourcePath of value.paths) sourcePaths.add(sourcePath);
-    }
-    if (agents.size < 2) continue;
-    overlaps.push({
-      token: `semantic:${root}`,
-      agents: [...agents].sort(),
-      sourcePaths: [...sourcePaths].sort(),
-      agentCount: agents.size
-    });
-  }
-  overlaps.sort((a, b) => b.agentCount - a.agentCount || a.token.localeCompare(b.token));
-  return {
-    overlaps,
-    candidateCount: tokenRows.length,
-    timedOut: false
-  };
-}
-async function computeSemanticOverlapsWithTimeout(sources, timeoutMs, maxCandidates) {
-  const safeTimeoutMs = Math.max(1, Math.floor(timeoutMs));
-  const safeMaxCandidates = Math.max(0, Math.floor(maxCandidates));
-  if (safeMaxCandidates === 0 || sources.length === 0) {
-    return { overlaps: [], candidateCount: 0, timedOut: false };
-  }
-  const timeoutAtMs = Date.now() + safeTimeoutMs;
-  return computeSemanticOverlapCandidates(sources, safeMaxCandidates, timeoutAtMs);
-}
-function feedbackDecisionPriority(decision) {
-  switch (decision) {
-    case "rejected":
-      return 3;
-    case "approved_with_feedback":
-      return 2;
-    case "approved":
-      return 1;
-  }
-}
-function feedbackSeverityPriority(severity) {
-  switch (severity) {
-    case "high":
-      return 3;
-    case "medium":
-      return 2;
-    case "low":
-      return 1;
-    default:
-      return 0;
-  }
-}
-function compareFeedbackPriority(a, b) {
-  return feedbackDecisionPriority(b.decision) - feedbackDecisionPriority(a.decision) || feedbackSeverityPriority(b.severity) - feedbackSeverityPriority(a.severity) || a.date.localeCompare(b.date);
-}
-function formatFeedbackLine(entry) {
-  const extras = [`feedback: ${entry.date}`];
-  if (entry.severity) extras.push(`severity: ${entry.severity}`);
-  if (entry.refs?.length) extras.push(`refs: ${entry.refs.join(", ")}`);
-  return `- [${entry.agent}] ${entry.decision}: ${entry.reason} [${extras.join("; ")}]`;
-}
-function formatOverlapLine(entry) {
-  return `- \`${entry.token}\` (${entry.agentCount} agents: ${entry.agents.join(", ")}) [sources: ${entry.sourcePaths.join(", ")}]`;
-}
 function resolveSharedContextDir(config) {
   return typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0 ? expandTildePath(config.sharedContextDir) : path.join(expandTildePath(config.workspaceDir), "shared-context");
 }
-var SharedContextManager = class {
-  constructor(config) {
-    this.config = config;
-    const base = resolveSharedContextDir(config);
-    this.dir = base;
-    this.prioritiesPath = path.join(base, "priorities.md");
-    this.prioritiesInboxPath = path.join(base, "priorities.inbox.md");
-    this.outputsDir = path.join(base, "agent-outputs");
-    this.roundtableDir = path.join(base, "roundtable");
-    this.feedbackDir = path.join(base, "feedback");
-    this.feedbackInboxPath = path.join(this.feedbackDir, "inbox.jsonl");
-    this.crossSignalsDir = path.join(base, "cross-signals");
-  }
-  config;
-  dir;
-  prioritiesPath;
-  prioritiesInboxPath;
-  outputsDir;
-  roundtableDir;
-  feedbackDir;
-  feedbackInboxPath;
-  crossSignalsDir;
-  async ensureStructure() {
-    await mkdir(this.dir, { recursive: true });
-    await mkdir(this.outputsDir, { recursive: true });
-    await mkdir(this.roundtableDir, { recursive: true });
-    await mkdir(this.feedbackDir, { recursive: true });
-    await mkdir(this.crossSignalsDir, { recursive: true });
-    await mkdir(path.join(this.dir, "staging"), { recursive: true });
-    await mkdir(path.join(this.dir, "kpis"), { recursive: true });
-    await mkdir(path.join(this.dir, "calendar"), { recursive: true });
-    await mkdir(path.join(this.dir, "content-calendar"), { recursive: true });
-    await this.ensureFile(
-      this.prioritiesPath,
-      [
-        "# Priorities",
-        "",
-        "This is the shared priority stack. Agents should read this before acting.",
-        "",
-        "## Current",
-        "- (empty)",
-        "",
-        "## Notes",
-        "- (empty)",
-        ""
-      ].join("\n")
-    );
-    await this.ensureFile(
-      this.prioritiesInboxPath,
-      [
-        "# Priorities Inbox",
-        "",
-        "Append-only inbox. Curator merges into priorities.md.",
-        ""
-      ].join("\n")
-    );
-    await this.ensureFile(this.feedbackInboxPath, "");
-  }
-  async ensureFile(fp, content) {
-    try {
-      await stat(fp);
-    } catch {
-      await writeFile(fp, content, "utf-8");
-    }
-  }
-  async readPriorities() {
-    try {
-      return await fileReader(this.prioritiesPath, "utf-8");
-    } catch {
-      return "";
-    }
-  }
-  async readLatestRoundtable() {
-    try {
-      const files = (await readdir(this.roundtableDir)).filter((f) => f.endsWith(".md")).sort().reverse();
-      const fp = files[0] ? path.join(this.roundtableDir, files[0]) : null;
-      if (!fp) return "";
-      return await fileReader(fp, "utf-8");
-    } catch {
-      return "";
-    }
-  }
-  async readLatestCrossSignals() {
-    try {
-      const files = (await readdir(this.crossSignalsDir)).filter((f) => f.endsWith(".md")).sort().reverse();
-      const fp = files[0] ? path.join(this.crossSignalsDir, files[0]) : null;
-      if (!fp) return "";
-      return await fileReader(fp, "utf-8");
-    } catch {
-      return "";
-    }
-  }
-  async writeAgentOutput(opts) {
-    const createdAt = opts.createdAt ?? /* @__PURE__ */ new Date();
-    const date = ymd(createdAt);
-    const time = createdAt.toISOString().slice(11, 19).replace(/:/g, "");
-    const slug = safeSlug(opts.title);
-    const dir = path.join(this.outputsDir, opts.agentId, date);
-    await mkdir(dir, { recursive: true });
-    const fp = path.join(dir, `${time}-${slug}.md`);
-    const body = `---
-kind: agent_output
-agent: ${opts.agentId}
-createdAt: ${createdAt.toISOString()}
-title: ${opts.title.replace(/\n/g, " ").slice(0, 200)}
----
-
-` + opts.content.trimEnd() + "\n";
-    await writeFile(fp, body, "utf-8");
-    return fp;
-  }
-  async appendFeedback(entry) {
-    const parsed = SharedFeedbackEntrySchema.parse(entry);
-    await appendFile(this.feedbackInboxPath, JSON.stringify(parsed) + "\n", "utf-8");
-  }
-  async appendPrioritiesInbox(opts) {
-    const stamp = (/* @__PURE__ */ new Date()).toISOString();
-    const lines = [
-      "",
-      `## ${stamp} (${opts.agentId})`,
-      "",
-      opts.text.trimEnd(),
-      ""
-    ].join("\n");
-    await appendFile(this.prioritiesInboxPath, lines, "utf-8");
-  }
-  async synthesizeCrossSignals(opts) {
-    const date = opts.date ?? ymd(/* @__PURE__ */ new Date());
-    const maxSummaryItems = Math.max(1, opts.maxSummaryItems ?? 8);
-    const outputs = [];
-    try {
-      const agents = await readdir(this.outputsDir, { withFileTypes: true });
-      for (const a of agents) {
-        if (!a.isDirectory()) continue;
-        const dayDir = path.join(this.outputsDir, a.name, date);
-        try {
-          const files = (await readdir(dayDir)).filter((f) => f.endsWith(".md")).sort();
-          for (const f of files) {
-            const p = path.join(dayDir, f);
-            const raw = await fileReader(p, "utf-8");
-            const title = (raw.match(/^title:\s*(.+)$/m)?.[1] ?? f).trim();
-            outputs.push({ agent: a.name, path: p, title, raw });
-          }
-        } catch {
-        }
-      }
-    } catch {
-    }
-    const feedback = [];
-    try {
-      const raw = await fileReader(this.feedbackInboxPath, "utf-8");
-      for (const line of raw.split("\n")) {
-        if (!line.trim()) continue;
-        try {
-          const obj = JSON.parse(line);
-          const parsed = SharedFeedbackEntrySchema.safeParse(obj);
-          if (!parsed.success) continue;
-          if (String(parsed.data.date).startsWith(date)) feedback.push(parsed.data);
-        } catch {
-        }
-      }
-    } catch {
-    }
-    const sources = outputs.map((output) => {
-      const body = stripYamlFrontmatter(output.raw);
-      return {
-        agent: output.agent,
-        path: output.path,
-        title: output.title,
-        topics: extractTopicTokens(`${output.title}
-${body}`)
-      };
-    });
-    const overlapMap = /* @__PURE__ */ new Map();
-    for (const source of sources) {
-      for (const token of source.topics) {
-        const existing = overlapMap.get(token);
-        if (existing) {
-          existing.agents.add(source.agent);
-          existing.sourcePaths.add(source.path);
-        } else {
-          overlapMap.set(token, {
-            agents: /* @__PURE__ */ new Set([source.agent]),
-            sourcePaths: /* @__PURE__ */ new Set([source.path])
-          });
-        }
-      }
-    }
-    const overlaps = [...overlapMap.entries()].map(([token, v]) => ({
-      token,
-      agents: [...v.agents].sort(),
-      sourcePaths: [...v.sourcePaths].sort(),
-      agentCount: v.agents.size
-    })).filter((entry) => entry.agentCount >= 2).sort((a, b) => b.agentCount - a.agentCount || a.token.localeCompare(b.token));
-    const semanticEnabled = this.config.sharedCrossSignalSemanticEnabled === true || this.config.crossSignalsSemanticEnabled === true;
-    const semanticTimeoutMs = this.config.sharedCrossSignalSemanticTimeoutMs ?? this.config.crossSignalsSemanticTimeoutMs ?? 4e3;
-    const semanticMaxCandidates = this.config.sharedCrossSignalSemanticMaxCandidates ?? 120;
-    let semanticApplied = false;
-    let semanticTimedOut = false;
-    let semanticCandidateCount = 0;
-    let semanticAddedOverlapCount = 0;
-    let mergedOverlaps = overlaps;
-    if (semanticEnabled) {
-      try {
-        const semanticResult = await computeSemanticOverlapsWithTimeout(
-          sources,
-          semanticTimeoutMs,
-          semanticMaxCandidates
-        );
-        semanticTimedOut = semanticResult.timedOut;
-        semanticCandidateCount = semanticResult.candidateCount;
-        if (!semanticResult.timedOut && semanticResult.overlaps.length > 0) {
-          mergedOverlaps = mergeOverlaps(overlaps, semanticResult.overlaps);
-          semanticAddedOverlapCount = Math.max(0, mergedOverlaps.length - overlaps.length);
-          semanticApplied = semanticAddedOverlapCount > 0;
-        }
-      } catch (err) {
-        log.warn(`shared-context semantic cross-signals failed; fail-open to deterministic output: ${err}`);
-      }
-    }
-    const feedbackByDecision = {
-      approved: 0,
-      approved_with_feedback: 0,
-      rejected: 0
-    };
-    for (const entry of feedback) {
-      feedbackByDecision[entry.decision] += 1;
-    }
-    const report = {
-      date,
-      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      sourceCount: sources.length,
-      feedbackCount: feedback.length,
-      feedbackByDecision,
-      feedbackEntries: [...feedback].sort(compareFeedbackPriority),
-      sources,
-      overlaps: mergedOverlaps,
-      semantic: {
-        enabled: semanticEnabled,
-        applied: semanticApplied,
-        timedOut: semanticTimedOut,
-        candidateCount: semanticCandidateCount,
-        maxCandidates: Math.max(0, Math.floor(semanticMaxCandidates)),
-        addedOverlapCount: semanticAddedOverlapCount
-      }
-    };
-    const crossSignalsPath = path.join(this.crossSignalsDir, `${date}.json`);
-    await writeFile(crossSignalsPath, `${JSON.stringify(report, null, 2)}
-`, "utf-8");
-    const recurringThemeLines = mergedOverlaps.length === 0 ? ["- No multi-agent topic overlap detected."] : mergedOverlaps.slice(0, maxSummaryItems).map((entry) => formatOverlapLine(entry));
-    const riskSignals = [...feedback].filter((entry) => entry.decision !== "approved" || entry.severity === "high" || entry.severity === "medium").sort(compareFeedbackPriority).slice(0, maxSummaryItems);
-    const riskLines = riskSignals.length === 0 ? ["- No explicit blockers or elevated review risks recorded."] : riskSignals.map((entry) => formatFeedbackLine(entry));
-    const promotionCandidates = mergedOverlaps.filter((entry) => entry.agentCount >= 3).slice(0, maxSummaryItems);
-    const promotionLines = promotionCandidates.length === 0 ? ["- No promotion candidates yet."] : promotionCandidates.map(
-      (entry) => `- Consider promoting \`${entry.token}\` into priorities or operating rules [sources: ${entry.sourcePaths.join(", ")}]`
-    );
-    const crossSignalsMarkdown = [
-      `# Cross-Signals \u2014 ${date}`,
-      "",
-      "## Overview",
-      `- Source outputs analyzed: ${sources.length}`,
-      `- Feedback entries analyzed: ${feedback.length}`,
-      `- Decision totals: approved=${feedbackByDecision.approved}, approved_with_feedback=${feedbackByDecision.approved_with_feedback}, rejected=${feedbackByDecision.rejected}`,
-      `- Semantic enhancer: ${semanticEnabled ? semanticTimedOut ? "enabled (timed out, fail-open)" : semanticApplied ? "enabled (applied)" : "enabled (no additional overlaps)" : "disabled"}`,
-      `- JSON report: ${crossSignalsPath}`,
-      "",
-      "## Recurring Themes",
-      ...recurringThemeLines,
-      "",
-      "## Risks And Blockers",
-      ...riskLines,
-      "",
-      "## Potential Promotions",
-      ...promotionLines,
-      "",
-      "## Sources",
-      ...sources.length === 0 ? ["- (none)"] : sources.map(
-        (source) => `- [${source.agent}] ${source.title} (${source.path})`
-      ),
-      ""
-    ].join("\n");
-    const crossSignalsMarkdownPath = path.join(this.crossSignalsDir, `${date}.md`);
-    await writeFile(crossSignalsMarkdownPath, crossSignalsMarkdown, "utf-8");
-    return {
-      date,
-      crossSignalsPath,
-      crossSignalsMarkdownPath,
-      overlapCount: mergedOverlaps.length,
-      report
-    };
-  }
-  async curateDaily(opts) {
-    const date = opts.date ?? ymd(/* @__PURE__ */ new Date());
-    const maxChars = Math.max(2e3, opts.maxChars ?? 2e4);
-    const crossSignals = await this.synthesizeCrossSignals({ date });
-    const feedbackLines = crossSignals.report.feedbackEntries.length === 0 ? ["- (none)"] : crossSignals.report.feedbackEntries.map((entry) => formatFeedbackLine(entry));
-    const overlapBullets = crossSignals.report.overlaps.length === 0 ? ["- No multi-agent topic overlap detected."] : crossSignals.report.overlaps.slice(0, 8).map((entry) => formatOverlapLine(entry));
-    const md = [
-      `# Roundtable \u2014 ${date}`,
-      "",
-      "## Notable Agent Outputs",
-      ...crossSignals.report.sources.length === 0 ? ["- (none)"] : crossSignals.report.sources.map((source) => `- ${source.title} (${source.path})`),
-      "",
-      "## Feedback (Approve/Reject)",
-      ...feedbackLines,
-      "",
-      "## Cross-Signals",
-      `- Source outputs analyzed: ${crossSignals.report.sourceCount}`,
-      `- Feedback entries analyzed: ${crossSignals.report.feedbackCount}`,
-      `- Decision totals: approved=${crossSignals.report.feedbackByDecision.approved}, approved_with_feedback=${crossSignals.report.feedbackByDecision.approved_with_feedback}, rejected=${crossSignals.report.feedbackByDecision.rejected}`,
-      `- Semantic enhancer: ${crossSignals.report.semantic.enabled ? crossSignals.report.semantic.timedOut ? "enabled (timed out, fail-open)" : crossSignals.report.semantic.applied ? "enabled (applied)" : "enabled (no additional overlaps)" : "disabled"}`,
-      `- Cross-signals JSON: ${crossSignals.crossSignalsPath}`,
-      `- Cross-signals markdown: ${crossSignals.crossSignalsMarkdownPath}`,
-      ...overlapBullets,
-      ""
-    ];
-    const out = md.join("\n");
-    const trimmed = out.length > maxChars ? out.slice(0, maxChars) + "\n\n...(trimmed)\n" : out;
-    const roundtablePath = path.join(this.roundtableDir, `${date}.md`);
-    await writeFile(roundtablePath, trimmed, "utf-8");
-    log.info(`shared-context curated daily roundtable: ${roundtablePath}`);
-    return {
-      date,
-      roundtablePath,
-      crossSignalsPath: crossSignals.crossSignalsPath,
-      crossSignalsMarkdownPath: crossSignals.crossSignalsMarkdownPath,
-      overlapCount: crossSignals.overlapCount
-    };
-  }
-};
 
 // ../remnic-core/src/compounding/engine.ts
 var COMPOUNDING_VERSION = 2;
@@ -842,7 +293,7 @@ var CompoundingEngine = class {
     let promotionCandidates = this.config.compoundingSemanticEnabled ? this.derivePromotionCandidates(outcomeSummary, mistakes.registry, rubrics) : [];
     if (this.config.cmcConsolidationEnabled) {
       try {
-        const { deriveCausalPromotionCandidates, materializeAfterCausalConsolidation } = await import("./causal-consolidation-DSLFN64P.js");
+        const { deriveCausalPromotionCandidates, materializeAfterCausalConsolidation } = await import("./causal-consolidation-DRPM2KOE.js");
         const causalCandidates = await deriveCausalPromotionCandidates({
           memoryDir: this.config.memoryDir,
           causalTrajectoryStoreDir: this.config.causalTrajectoryStoreDir,
@@ -875,7 +326,7 @@ var CompoundingEngine = class {
     }
     if (this.config.calibrationEnabled) {
       try {
-        const { runCalibrationConsolidation } = await import("./calibration-JD4AU7FB.js");
+        const { runCalibrationConsolidation } = await import("./calibration-RKL2LRW4.js");
         const calRules = await runCalibrationConsolidation({
           memoryDir: this.config.memoryDir,
           gatewayConfig: this.config.gatewayConfig,
@@ -1839,7 +1290,6 @@ var CompoundingEngine = class {
 };
 
 export {
-  SharedContextManager,
   defaultTierMigrationCycleBudget,
   CompoundingEngine
 };

package/dist/{chunk-4G2XCSD2.js → chunk-BZ4EYURA.js}

@@ -11,9 +11,6 @@ function clamp01(value) {
   if (value > 1) return 1;
   return value;
 }
-function clampLifecycleThreshold(value) {
-  return clamp01(value);
-}
 function parseIsoMs(value) {
   if (!value) return null;
   const ms = Date.parse(value);
@@ -178,9 +175,7 @@ function decideLifecycleTransition(memory, policy, now, signals) {
 
 export {
   clamp01,
-  clampLifecycleThreshold,
   daysSince,
-  resolveLifecycleState,
   computeLifecycleValueInputs,
   decideLifecycleTransition
 };

package/dist/{chunk-4LYQ4ONL.js → chunk-E4RM7637.js}

@@ -1,6 +1,6 @@
 import {
   external_exports
-} from "./chunk-EXDYWXMB.js";
+} from "./chunk-4XDQ3KEC.js";
 
 // ../remnic-core/src/transfer/types.ts
 var ExportManifestV1Schema = external_exports.object({

package/dist/{chunk-TDRJVMUP.js → chunk-EH4AXGRO.js}

@@ -31,17 +31,6 @@ function readEnvVar(name) {
 function resolveHomeDir() {
   return readEnvVar("HOME") || os.homedir();
 }
-function cloneEnv() {
-  return { ...getEnvMap() ?? {} };
-}
-function mergeEnv(overrides) {
-  const merged = cloneEnv();
-  for (const [key, value] of Object.entries(overrides)) {
-    if (typeof value === "string") merged[key] = value;
-    else delete merged[key];
-  }
-  return merged;
-}
 
 // ../remnic-core/src/utils/path.ts
 function expandTildePath(p) {
@@ -55,6 +44,5 @@ function expandTildePath(p) {
 export {
   readEnvVar,
   resolveHomeDir,
-  mergeEnv,
   expandTildePath
 };