@remnic/plugin-openclaw 1.0.10 → 1.0.11

package/dist/chunk-ETJZRIAM.js

@@ -0,0 +1,227 @@
+import {
+  parseExportBundle
+} from "./chunk-K7EUBNDD.js";
+import {
+  assertIsDirectoryNotSymlink,
+  assertRealpathInsideRoot,
+  fromPosixRelPath,
+  isPathInsideRoot,
+  sha256String
+} from "./chunk-NKVIN6RD.js";
+import {
+  decryptCapsuleFileInMemory,
+  isEncryptedCapsuleFile
+} from "./chunk-SSFTU6LP.js";
+import {
+  createVersion
+} from "./chunk-6OJAU466.js";
+
+// ../remnic-core/src/transfer/capsule-import.ts
+import { lstat, mkdir, readFile, realpath, stat, writeFile } from "fs/promises";
+import path from "path";
+import { createHash, randomUUID } from "crypto";
+import { gunzipSync } from "zlib";
+async function importCapsule(opts) {
+  const archiveAbs = path.resolve(opts.archivePath);
+  const rootAbs = path.resolve(opts.root);
+  await assertIsDirectoryNotSymlink(rootAbs, "importCapsule", "root");
+  const mode = opts.mode ?? "skip";
+  if (mode !== "skip" && mode !== "overwrite" && mode !== "fork") {
+    throw new Error(
+      `importCapsule: unknown mode ${JSON.stringify(mode)}; expected "skip", "overwrite", or "fork"`
+    );
+  }
+  const encrypted = await isEncryptedCapsuleFile(archiveAbs);
+  let raw;
+  if (encrypted) {
+    if (!opts.memoryDir) {
+      throw new Error(
+        `importCapsule: archive is encrypted but 'memoryDir' was not provided. Pass the memory directory so the secure-store key can be retrieved, or run \`remnic secure-store unlock\` before importing.`
+      );
+    }
+    raw = await decryptCapsuleFileInMemory(archiveAbs, opts.memoryDir);
+  } else {
+    raw = await readFile(archiveAbs);
+  }
+  const json = gunzipSync(raw).toString("utf-8");
+  let parsedJson;
+  try {
+    parsedJson = JSON.parse(json);
+  } catch (cause) {
+    throw new Error(
+      `importCapsule: archive is not valid JSON after gunzip: ${archiveAbs}`,
+      { cause }
+    );
+  }
+  const parsed = parseExportBundle(parsedJson);
+  if (parsed.capsuleVersion !== 2) {
+    throw new Error(
+      "importCapsule: archive is V1; only V2 capsule archives are supported"
+    );
+  }
+  const bundle = parsed.bundle;
+  const manifest = bundle.manifest;
+  const capsule = manifest.capsule;
+  const manifestIndex = /* @__PURE__ */ new Map();
+  for (const f of manifest.files) {
+    manifestIndex.set(f.path, f);
+  }
+  if (manifestIndex.size !== manifest.files.length) {
+    throw new Error(
+      "importCapsule: manifest contains duplicate file paths"
+    );
+  }
+  const recordPaths = /* @__PURE__ */ new Set();
+  for (const rec of bundle.records) {
+    if (recordPaths.has(rec.path)) {
+      throw new Error(
+        `importCapsule: bundle contains duplicate record path: ${rec.path}`
+      );
+    }
+    recordPaths.add(rec.path);
+  }
+  const rootReal = await realpath(rootAbs).catch(() => rootAbs);
+  const seenTargetPaths = /* @__PURE__ */ new Map();
+  for (const rec of bundle.records) {
+    const entry = manifestIndex.get(rec.path);
+    if (!entry) {
+      throw new Error(
+        `importCapsule: archive checksum mismatch (record without manifest entry: ${rec.path})`
+      );
+    }
+    const { sha256, bytes } = sha256String(rec.content);
+    if (sha256 !== entry.sha256 || bytes !== entry.bytes) {
+      throw new Error(
+        `importCapsule: archive checksum mismatch for ${rec.path}: expected sha256=${entry.sha256} bytes=${entry.bytes}, got sha256=${sha256} bytes=${bytes}`
+      );
+    }
+    if (rec.path.includes("\\")) {
+      throw new Error(
+        `importCapsule: record path contains backslash separators (Windows-style paths are not allowed): ${rec.path}`
+      );
+    }
+    const posixNormalized = path.posix.normalize(rec.path);
+    if (rec.path.startsWith("/") || rec.path.split("/").some((seg) => seg === "..") || posixNormalized.startsWith("..") || posixNormalized.startsWith("/")) {
+      throw new Error(
+        `importCapsule: record path escapes target root: ${rec.path}`
+      );
+    }
+    const targetRel = computeTargetPath(rec.path, mode, capsule.id);
+    const targetAbs = path.join(rootReal, fromPosixRelPath(targetRel));
+    if (!isPathInsideRoot(rootReal, targetAbs)) {
+      throw new Error(
+        `importCapsule: record path escapes target root: ${rec.path}`
+      );
+    }
+    await assertRealpathInsideRoot(rootReal, targetAbs, rec.path, "importCapsule");
+    const targetLstat = await lstat(targetAbs).catch(() => null);
+    if (targetLstat !== null && targetLstat.isSymbolicLink()) {
+      throw new Error(
+        `importCapsule: record target is a symlink and cannot be written to safely: ${rec.path}`
+      );
+    }
+    const dedupKey = targetAbs.toLowerCase();
+    const firstSourcePath = seenTargetPaths.get(dedupKey);
+    if (firstSourcePath !== void 0) {
+      throw new Error(
+        `importCapsule: manifest contains two entries that resolve to the same target path: "${firstSourcePath}" and "${rec.path}" both map to "${targetRel}"`
+      );
+    }
+    seenTargetPaths.set(dedupKey, rec.path);
+  }
+  for (const f of manifest.files) {
+    if (!recordPaths.has(f.path)) {
+      throw new Error(
+        `importCapsule: archive checksum mismatch (manifest entry without record: ${f.path})`
+      );
+    }
+  }
+  const imported = [];
+  const skipped = [];
+  const sortedRecords = [...bundle.records].sort(
+    (a, b) => a.path.localeCompare(b.path)
+  );
+  for (const rec of sortedRecords) {
+    const targetRel = computeTargetPath(rec.path, mode, capsule.id);
+    const targetAbs = path.join(rootReal, fromPosixRelPath(targetRel));
+    const exists = await fileExistsAt(targetAbs);
+    if ((mode === "skip" || mode === "fork") && exists) {
+      skipped.push({ path: rec.path, reason: "exists" });
+      continue;
+    }
+    let snapshotted = false;
+    if (mode === "overwrite" && exists) {
+      if (opts.versioning && opts.versioning.enabled) {
+        const prior = await readFile(targetAbs, "utf-8").catch(() => "");
+        await createVersion(
+          targetAbs,
+          prior,
+          "manual",
+          opts.versioning,
+          opts.log,
+          `capsule-import: ${capsule.id}`,
+          rootReal
+        );
+        snapshotted = true;
+      }
+    }
+    let contentToWrite = rec.content;
+    let rewroteId = false;
+    if (mode === "fork") {
+      const forked = rewriteFrontmatterIdForFork(rec.content, capsule.id, opts.now);
+      contentToWrite = forked.content;
+      rewroteId = forked.rewrote;
+    }
+    await mkdir(path.dirname(targetAbs), { recursive: true });
+    await writeFile(targetAbs, contentToWrite, "utf-8");
+    imported.push({
+      sourcePath: rec.path,
+      targetPath: targetRel,
+      snapshotted,
+      rewroteId
+    });
+  }
+  skipped.sort((a, b) => a.path.localeCompare(b.path));
+  return { imported, skipped, manifest };
+}
+function computeTargetPath(sourcePosix, mode, capsuleId) {
+  if (mode === "fork") return `forks/${capsuleId}/${sourcePosix}`;
+  return sourcePosix;
+}
+async function fileExistsAt(absPath) {
+  const st = await stat(absPath).catch(() => null);
+  return st !== null && st.isFile();
+}
+function rewriteFrontmatterIdForFork(content, capsuleId, now) {
+  const crlfMatch = /^---(\r\n|\r|\n)/.exec(content);
+  const eol = crlfMatch ? crlfMatch[1] : "\n";
+  const fmMatch = /^---\r?\n([\s\S]*?)\r?\n---(\r?\n|$)/.exec(content);
+  if (!fmMatch) return { content, rewrote: false };
+  const fmBody = fmMatch[1];
+  const fmTrailer = fmMatch[2];
+  const fmStart = fmMatch.index;
+  const fmEnd = fmStart + fmMatch[0].length;
+  const idLineRe = /^id:[ \t]*([^\r\n]*)$/m;
+  const idMatch = idLineRe.exec(fmBody);
+  if (!idMatch) return { content, rewrote: false };
+  const newId = mintForkId(capsuleId, idMatch[1]?.trim() ?? "", now);
+  const replacedBody = fmBody.replace(idLineRe, `id: ${newId}`);
+  const prefix = content.slice(0, fmStart);
+  const tail = content.slice(fmEnd);
+  const rebuilt = `${prefix}---${eol}${replacedBody}${eol}---${fmTrailer}${tail}`;
+  return { content: rebuilt, rewrote: true };
+}
+function mintForkId(capsuleId, originalId, now) {
+  const base = originalId.length > 0 ? originalId : "fork";
+  if (now === void 0) {
+    const suffix2 = randomUUID().slice(0, 8);
+    return `${base}-fork-${capsuleId}-${suffix2}`;
+  }
+  const payload = JSON.stringify({ c: capsuleId, i: originalId, n: now });
+  const suffix = createHash("sha256").update(payload, "utf-8").digest("hex").slice(0, 8);
+  return `${base}-fork-${capsuleId}-${suffix}`;
+}
+
+export {
+  importCapsule
+};

package/dist/chunk-FQRSVYY4.js

@@ -0,0 +1,110 @@
+// ../remnic-core/src/routing/engine.ts
+var DEFAULT_CATEGORIES = [
+  "fact",
+  "preference",
+  "correction",
+  "entity",
+  "decision",
+  "relationship",
+  "principle",
+  "commitment",
+  "moment",
+  "skill",
+  "rule",
+  "procedure",
+  "reasoning_trace"
+];
+function normalizeNamespace(namespace) {
+  return namespace.trim();
+}
+function isLikelyUnsafeRegex(pattern) {
+  const value = pattern.trim();
+  if (value.length === 0) return true;
+  if (value.length > 120) return true;
+  if (/\\[1-9]/.test(value)) return true;
+  if (/\(\?<?[=!]/.test(value)) return true;
+  if (/\((?:[^()\\]|\\.)*[+*](?:[^()\\]|\\.)*\)[+*{]/.test(value)) return true;
+  if (/(^|[^\\])[()|]/.test(value)) return true;
+  const quantifierCount = (value.match(/(^|[^\\])[*+?]/g)?.length ?? 0) + (value.match(/(^|[^\\])\{/g)?.length ?? 0);
+  if (quantifierCount > 1) return true;
+  return false;
+}
+function isSafeRouteNamespace(namespace) {
+  const value = normalizeNamespace(namespace);
+  if (value.length === 0) return false;
+  if (value === ".") return false;
+  if (value.includes("/") || value.includes("\\")) return false;
+  if (value.includes("..")) return false;
+  return /^[A-Za-z0-9._-]{1,64}$/.test(value);
+}
+function validateRouteTarget(target, options) {
+  if (!target || typeof target !== "object") {
+    return { ok: false, error: "target must be an object" };
+  }
+  const allowedCategories = new Set(options?.allowedCategories ?? DEFAULT_CATEGORIES);
+  const allowedNamespaces = options?.allowedNamespaces ? new Set(options.allowedNamespaces.map((v) => v.trim()).filter((v) => v.length > 0)) : null;
+  const normalized = {};
+  if (typeof target.category === "string") {
+    if (!allowedCategories.has(target.category)) {
+      return { ok: false, error: `invalid category: ${target.category}` };
+    }
+    normalized.category = target.category;
+  }
+  if (typeof target.namespace === "string") {
+    const namespace = normalizeNamespace(target.namespace);
+    if (!isSafeRouteNamespace(namespace)) {
+      return { ok: false, error: `invalid namespace: ${target.namespace}` };
+    }
+    if (allowedNamespaces && !allowedNamespaces.has(namespace)) {
+      return { ok: false, error: `namespace not allowed: ${namespace}` };
+    }
+    normalized.namespace = namespace;
+  }
+  if (!normalized.category && !normalized.namespace) {
+    return { ok: false, error: "target must include category or namespace" };
+  }
+  return { ok: true, target: normalized };
+}
+function doesRuleMatch(rule, text) {
+  if (!rule || typeof rule !== "object") return false;
+  if (rule.enabled === false) return false;
+  if (typeof rule.pattern !== "string") return false;
+  const pattern = rule.pattern.trim();
+  if (pattern.length === 0) return false;
+  if (rule.patternType === "keyword") {
+    return text.toLowerCase().includes(pattern.toLowerCase());
+  }
+  if (rule.patternType !== "regex") {
+    return false;
+  }
+  if (isLikelyUnsafeRegex(pattern)) {
+    return false;
+  }
+  try {
+    return new RegExp(pattern, "i").test(text);
+  } catch {
+    return false;
+  }
+}
+function selectRouteRule(text, rules, options) {
+  const ranked = rules.map((rule, index) => ({ rule, index })).sort((a, b) => {
+    if (b.rule.priority !== a.rule.priority) return b.rule.priority - a.rule.priority;
+    return a.index - b.index;
+  });
+  for (const entry of ranked) {
+    if (!doesRuleMatch(entry.rule, text)) continue;
+    const validation = validateRouteTarget(entry.rule.target, options);
+    if (!validation.ok || !validation.target) continue;
+    return {
+      rule: entry.rule,
+      target: validation.target
+    };
+  }
+  return null;
+}
+
+export {
+  isSafeRouteNamespace,
+  validateRouteTarget,
+  selectRouteRule
+};

package/dist/chunk-HRGFO6AW.js

@@ -0,0 +1,349 @@
+import {
+  PEER_ID_PATTERN,
+  appendInteractionLog,
+  listPeers,
+  readPeerInteractionLog,
+  readPeerProfile,
+  writePeerProfile
+} from "./chunk-TLVIQLB4.js";
+
+// ../remnic-core/src/peers/profile-reasoner.ts
+function buildPeerProfileReasonerPrompt(input) {
+  const existingFields = input.existingProfile ? Object.keys(input.existingProfile.fields) : [];
+  const logBlock = input.log.map((e) => {
+    const session = e.sessionId ? ` session=${e.sessionId}` : "";
+    return `- [${e.timestamp}] (${e.kind})${session} ${e.summary}`;
+  }).join("\n");
+  return [
+    `You are an async peer-profile reasoner. Your job is to read recent interaction-log entries for one peer and propose 0..${input.maxFields} profile-field updates.`,
+    "",
+    `Peer:`,
+    `  id: ${input.peer.id}`,
+    `  kind: ${input.peer.kind}`,
+    `  displayName: ${input.peer.displayName}`,
+    "",
+    `Existing profile field keys (preserve names when proposing updates that refine an existing field): ${existingFields.length > 0 ? existingFields.join(", ") : "(none yet)"}`,
+    "",
+    `Recent interaction log (oldest first):`,
+    logBlock.length > 0 ? logBlock : "(no entries)",
+    "",
+    `Output a single JSON object: {"proposals": [{"field": "<stable_key>", "value": "<markdown>", "signal": "<short_label>", "note": "<optional>", "sourceSessionId": "<optional>"}]}.`,
+    "",
+    `Rules:`,
+    `1. Only propose fields supported by evidence in the log. Do not invent.`,
+    `2. Keys are short snake_case (e.g. "communication_style", "tool_patterns").`,
+    `3. value is markdown. signal is a short label like "explicit_preference" or "topic_recurrence".`,
+    `4. Omit fields you can't justify. Empty proposals array is valid.`,
+    `5. Output JSON ONLY \u2014 no prose before or after.`
+  ].join("\n");
+}
+function parsePeerProfileReasonerResponse(raw) {
+  if (typeof raw !== "string" || raw.trim() === "") return [];
+  const trimmed = raw.trim();
+  const fenced = /^```(?:json)?\s*([\s\S]*?)```\s*$/u.exec(trimmed);
+  const payload = fenced ? fenced[1].trim() : trimmed;
+  let parsed;
+  try {
+    parsed = JSON.parse(payload);
+  } catch {
+    return [];
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return [];
+  }
+  const obj = parsed;
+  if (!Array.isArray(obj.proposals)) return [];
+  const out = [];
+  const RESERVED_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+  for (const item of obj.proposals) {
+    if (typeof item !== "object" || item === null || Array.isArray(item)) continue;
+    const r = item;
+    if (typeof r.field !== "string" || r.field.trim() === "") continue;
+    if (RESERVED_KEYS.has(r.field)) continue;
+    if (typeof r.value !== "string" || r.value.trim() === "") continue;
+    if (typeof r.signal !== "string" || r.signal.trim() === "") continue;
+    const proposal = {
+      field: r.field,
+      value: r.value,
+      signal: r.signal,
+      ...typeof r.note === "string" && r.note.length > 0 ? { note: r.note } : {},
+      ...typeof r.sourceSessionId === "string" && r.sourceSessionId.length > 0 ? { sourceSessionId: r.sourceSessionId } : {}
+    };
+    out.push(proposal);
+  }
+  return out;
+}
+var SYSTEM_MESSAGE = 'You are a peer-profile reasoner. Output ONLY a JSON object of the form {"proposals":[{"field":"...","value":"...","signal":"...","note":"...","sourceSessionId":"..."}]}. No prose, no fenced code block, no commentary.';
+var RUN_MARKER_KIND = "peer_profile_reasoner_run";
+function lastRunTimestamp(log) {
+  let latest;
+  for (const entry of log) {
+    if (entry.kind !== RUN_MARKER_KIND) continue;
+    if (latest === void 0 || entry.timestamp > latest) {
+      latest = entry.timestamp;
+    }
+  }
+  return latest;
+}
+function noopLogger() {
+  return { debug: () => {
+  }, info: () => {
+  }, warn: () => {
+  } };
+}
+async function runPeerProfileReasoner(options) {
+  const log = {
+    debug: options.log?.debug ?? noopLogger().debug,
+    info: options.log?.info ?? noopLogger().info,
+    warn: options.log?.warn ?? noopLogger().warn
+  };
+  const result = {
+    peersConsidered: 0,
+    peersProcessed: 0,
+    fieldsApplied: 0,
+    perPeer: []
+  };
+  if (options.enabled !== true) {
+    log.debug("[peer-profile-reasoner] disabled \u2014 no-op");
+    return result;
+  }
+  if (!options.llm) {
+    log.warn("[peer-profile-reasoner] no LLM client supplied \u2014 skipping run");
+    return result;
+  }
+  const minInteractions = Number.isFinite(options.minInteractions) ? Math.max(0, Math.floor(options.minInteractions)) : 0;
+  const maxFields = Number.isFinite(options.maxFieldsPerRun) ? Math.max(0, Math.floor(options.maxFieldsPerRun)) : 0;
+  if (maxFields === 0) {
+    log.debug("[peer-profile-reasoner] maxFieldsPerRun=0 \u2014 no-op");
+    return result;
+  }
+  const maxLogPerPeer = Number.isFinite(options.maxLogEntriesPerPeer ?? NaN) ? Math.max(1, Math.floor(options.maxLogEntriesPerPeer)) : 50;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const nowIso = now.toISOString();
+  let peers;
+  try {
+    if (options.peerIds && options.peerIds.length > 0) {
+      const all = await listPeers(options.memoryDir);
+      const wanted = new Set(
+        options.peerIds.filter(
+          (id) => typeof id === "string" && PEER_ID_PATTERN.test(id)
+        )
+      );
+      peers = all.filter((p) => wanted.has(p.id));
+    } else {
+      peers = await listPeers(options.memoryDir);
+    }
+  } catch (err) {
+    log.warn(
+      `[peer-profile-reasoner] listPeers failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return result;
+  }
+  result.peersConsidered = peers.length;
+  let fieldsAppliedTotal = 0;
+  for (const peer of peers) {
+    if (options.signal?.aborted) {
+      result.perPeer.push({
+        peerId: peer.id,
+        status: "skipped_aborted",
+        fieldsApplied: 0,
+        droppedDueToCap: 0,
+        fields: []
+      });
+      continue;
+    }
+    try {
+      const fullLog = await readPeerInteractionLog(
+        options.memoryDir,
+        peer.id
+      );
+      if (fullLog.length === 0) {
+        result.perPeer.push({
+          peerId: peer.id,
+          status: "skipped_no_log",
+          fieldsApplied: 0,
+          droppedDueToCap: 0,
+          fields: []
+        });
+        continue;
+      }
+      const lastRun = lastRunTimestamp(fullLog);
+      const sinceLastRunFull = lastRun ? fullLog.filter(
+        (e) => e.timestamp > lastRun && e.kind !== RUN_MARKER_KIND
+      ) : fullLog.filter((e) => e.kind !== RUN_MARKER_KIND);
+      if (sinceLastRunFull.length < minInteractions) {
+        result.perPeer.push({
+          peerId: peer.id,
+          status: "skipped_below_min_interactions",
+          fieldsApplied: 0,
+          droppedDueToCap: 0,
+          fields: []
+        });
+        continue;
+      }
+      const sinceLastRun = sinceLastRunFull.length > maxLogPerPeer ? sinceLastRunFull.slice(sinceLastRunFull.length - maxLogPerPeer) : sinceLastRunFull;
+      const existingProfile = await readPeerProfile(options.memoryDir, peer.id);
+      const remainingBudget = maxFields - fieldsAppliedTotal;
+      if (remainingBudget <= 0) {
+        result.perPeer.push({
+          peerId: peer.id,
+          status: "skipped_cap_reached",
+          fieldsApplied: 0,
+          droppedDueToCap: 0,
+          fields: []
+        });
+        continue;
+      }
+      const prompt = buildPeerProfileReasonerPrompt({
+        peer,
+        existingProfile,
+        log: sinceLastRun,
+        maxFields: remainingBudget
+      });
+      const messages = [
+        { role: "system", content: SYSTEM_MESSAGE },
+        { role: "user", content: prompt }
+      ];
+      let response;
+      try {
+        response = await options.llm.chatCompletion(messages, {
+          temperature: 0.2,
+          maxTokens: 1500
+        });
+      } catch (err) {
+        log.warn(
+          `[peer-profile-reasoner] LLM call failed for "${peer.id}": ${err instanceof Error ? err.message : String(err)}`
+        );
+        result.perPeer.push({
+          peerId: peer.id,
+          status: "skipped_llm_unavailable",
+          fieldsApplied: 0,
+          droppedDueToCap: 0,
+          fields: []
+        });
+        continue;
+      }
+      if (!response || typeof response.content !== "string") {
+        result.perPeer.push({
+          peerId: peer.id,
+          status: "skipped_llm_unavailable",
+          fieldsApplied: 0,
+          droppedDueToCap: 0,
+          fields: []
+        });
+        continue;
+      }
+      const proposals = parsePeerProfileReasonerResponse(response.content);
+      if (proposals.length === 0) {
+        result.perPeer.push({
+          peerId: peer.id,
+          status: "processed",
+          fieldsApplied: 0,
+          droppedDueToCap: 0,
+          fields: []
+        });
+        continue;
+      }
+      const sessionIdsInWindow = new Set(
+        sinceLastRun.map((e) => e.sessionId).filter((s) => typeof s === "string" && s.length > 0)
+      );
+      const baseFields = existingProfile ? { ...existingProfile.fields } : {};
+      const baseProvenance = {};
+      if (existingProfile) {
+        for (const [k, list] of Object.entries(existingProfile.provenance)) {
+          baseProvenance[k] = [...list];
+        }
+      }
+      const appliedFieldsForPeer = [];
+      let droppedDueToCap = 0;
+      let invalidProposalSeen = false;
+      for (const proposal of proposals) {
+        const candidateBudget = maxFields - fieldsAppliedTotal - appliedFieldsForPeer.length;
+        if (candidateBudget <= 0) {
+          droppedDueToCap += 1;
+          continue;
+        }
+        if (proposal.field === "__proto__" || proposal.field === "constructor" || proposal.field === "prototype") {
+          invalidProposalSeen = true;
+          continue;
+        }
+        if (!/^[a-zA-Z][a-zA-Z0-9_]{0,63}$/.test(proposal.field)) {
+          invalidProposalSeen = true;
+          continue;
+        }
+        baseFields[proposal.field] = proposal.value;
+        const sourceSessionId = proposal.sourceSessionId && sessionIdsInWindow.has(proposal.sourceSessionId) ? proposal.sourceSessionId : void 0;
+        const provEntry = {
+          observedAt: nowIso,
+          signal: proposal.signal,
+          ...sourceSessionId ? { sourceSessionId } : {},
+          ...proposal.note && proposal.note.length > 0 ? { note: proposal.note } : {}
+        };
+        const list = baseProvenance[proposal.field] ?? [];
+        list.push(provEntry);
+        baseProvenance[proposal.field] = list;
+        appliedFieldsForPeer.push(proposal.field);
+      }
+      if (appliedFieldsForPeer.length === 0) {
+        result.perPeer.push({
+          peerId: peer.id,
+          status: invalidProposalSeen ? "skipped_invalid_proposal" : droppedDueToCap > 0 ? "skipped_cap_reached" : "processed",
+          fieldsApplied: 0,
+          droppedDueToCap,
+          fields: []
+        });
+        continue;
+      }
+      const merged = {
+        peerId: peer.id,
+        updatedAt: nowIso,
+        fields: baseFields,
+        provenance: baseProvenance
+      };
+      await writePeerProfile(options.memoryDir, merged);
+      fieldsAppliedTotal += appliedFieldsForPeer.length;
+      const wantsMarker = options.appendRunMarkerToLog ?? true;
+      if (wantsMarker) {
+        try {
+          await appendInteractionLog(options.memoryDir, peer.id, {
+            timestamp: nowIso,
+            kind: RUN_MARKER_KIND,
+            summary: `applied ${appliedFieldsForPeer.length} field(s) via ${options.model ?? "unknown-model"}`
+          });
+        } catch (err) {
+          log.warn(
+            `[peer-profile-reasoner] run-marker append failed for "${peer.id}": ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+      result.perPeer.push({
+        peerId: peer.id,
+        status: "processed",
+        fieldsApplied: appliedFieldsForPeer.length,
+        droppedDueToCap,
+        fields: appliedFieldsForPeer
+      });
+      result.peersProcessed += 1;
+      result.fieldsApplied = fieldsAppliedTotal;
+    } catch (err) {
+      log.warn(
+        `[peer-profile-reasoner] error processing peer "${peer.id}": ${err instanceof Error ? err.message : String(err)}`
+      );
+      result.perPeer.push({
+        peerId: peer.id,
+        status: "error",
+        fieldsApplied: 0,
+        droppedDueToCap: 0,
+        fields: [],
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return result;
+}
+
+export {
+  buildPeerProfileReasonerPrompt,
+  parsePeerProfileReasonerResponse,
+  runPeerProfileReasoner
+};