@askexenow/exe-os 0.9.286 → 0.9.288

package/dist/catchup-brief-TFL6MYOZ.js

@@ -0,0 +1,154 @@
+import {
+  lightweightSearch
+} from "./chunk-6GOT6FNJ.js";
+import "./chunk-AB4PAQYK.js";
+import "./chunk-YEHV3FN5.js";
+import "./chunk-CHCA3ZM2.js";
+import "./chunk-OTVEIJUQ.js";
+import "./chunk-2CO47E5Q.js";
+import "./chunk-Y25OJWOQ.js";
+import {
+  sessionScopeFilter,
+  strictSessionScopeFilter
+} from "./chunk-5XOAYMSU.js";
+import "./chunk-Z5P7AUFM.js";
+import "./chunk-4JERP7NT.js";
+import "./chunk-4FVVJ7ME.js";
+import "./chunk-WO2SPDUE.js";
+import "./chunk-MVW62NIZ.js";
+import "./chunk-OYNKIAVW.js";
+import "./chunk-SSTLTIF3.js";
+import "./chunk-JMR2X5FJ.js";
+import "./chunk-PMVOUPTY.js";
+import "./chunk-NGP6LSV2.js";
+import "./chunk-MUDH7ZLR.js";
+import "./chunk-CVYC6DUW.js";
+import "./chunk-OPU3NYOO.js";
+import "./chunk-GJV3WDWM.js";
+import "./chunk-MP2AFCGL.js";
+import "./chunk-VWZZF3YB.js";
+import "./chunk-HYZV25LY.js";
+import {
+  getClient
+} from "./chunk-WLDBPKRL.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-R5LCP56X.js";
+import "./chunk-5DNJPRDW.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-Z42MXYWW.js";
+import "./chunk-YMKUXZIG.js";
+import "./chunk-T3B5RK4H.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+
+// src/lib/catchup-brief.ts
+import { execSync } from "child_process";
+var HEADER = "## Catchup Brief\nHere's what happened while you were offline:";
+var DEFAULT_LOOKBACK_MS = 60 * 60 * 1e3;
+var MAX_BRIEF_CHARS = 2e3;
+var MAX_CHECKPOINT_CHARS = 500;
+var MAX_MESSAGE_CHARS = 100;
+function clipText(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  if (maxChars <= 1) return "\u2026";
+  return `${text.slice(0, maxChars - 1).trimEnd()}\u2026`;
+}
+function clampSections(header, sections, maxChars) {
+  const bounded = [];
+  let remaining = Math.max(0, maxChars - header.length);
+  for (const section of sections) {
+    const separatorChars = 2;
+    if (remaining <= separatorChars) break;
+    remaining -= separatorChars;
+    if (section.length <= remaining) {
+      bounded.push(section);
+      remaining -= section.length;
+      continue;
+    }
+    const clipped = clipText(section, remaining);
+    if (clipped.trim().length > 0) bounded.push(clipped);
+    break;
+  }
+  return bounded;
+}
+async function buildCatchupBrief(agentId, projectName, cwd, sessionScope) {
+  const sections = [];
+  let lastTimestamp = new Date(Date.now() - DEFAULT_LOOKBACK_MS).toISOString();
+  try {
+    const checkpointMemories = await lightweightSearch(
+      "CONTEXT CHECKPOINT",
+      agentId,
+      { projectName, limit: 1 }
+    );
+    const checkpoint = checkpointMemories[0];
+    if (checkpoint?.timestamp) {
+      lastTimestamp = checkpoint.timestamp;
+    }
+    if (checkpoint?.raw_text) {
+      sections.push(
+        `### Last Checkpoint
+${clipText(checkpoint.raw_text, MAX_CHECKPOINT_CHARS)}`
+      );
+    }
+  } catch {
+  }
+  try {
+    const gitLog = execSync(
+      `git log --oneline --since=${JSON.stringify(lastTimestamp)} --format="%h %an: %s" | head -10`,
+      { cwd, timeout: 3e3, encoding: "utf-8" }
+    ).trim();
+    if (gitLog) {
+      sections.push(`### Git Activity Since You Left
+\`\`\`
+${gitLog}
+\`\`\``);
+    }
+  } catch {
+  }
+  try {
+    const client = getClient();
+    const taskScope = sessionScopeFilter(sessionScope);
+    const taskChanges = await client.execute({
+      sql: `SELECT title, status, priority FROM tasks
+            WHERE assigned_to = ? AND project_name = ?
+              AND updated_at > ? AND status IN ('open', 'in_progress')${taskScope.sql}
+            ORDER BY priority ASC, updated_at DESC LIMIT 5`,
+      args: [agentId, projectName, lastTimestamp, ...taskScope.args]
+    });
+    if (taskChanges.rows.length > 0) {
+      const taskLines = taskChanges.rows.map((row) => {
+        const record = row;
+        return `- [${String(record.priority).toUpperCase()}] ${String(record.title)} (${String(record.status)})`;
+      }).join("\n");
+      sections.push(`### Your Task Queue
+${taskLines}`);
+    }
+  } catch {
+  }
+  try {
+    const client = getClient();
+    const messageScope = strictSessionScopeFilter(sessionScope);
+    const messages = await client.execute({
+      sql: `SELECT from_agent, content, created_at FROM messages
+            WHERE target_agent = ? AND status = 'pending'${messageScope.sql}
+            ORDER BY created_at DESC LIMIT 3`,
+      args: [agentId, ...messageScope.args]
+    });
+    if (messages.rows.length > 0) {
+      const msgLines = messages.rows.map((row) => {
+        const record = row;
+        return `- From ${String(record.from_agent)}: ${clipText(String(record.content ?? ""), MAX_MESSAGE_CHARS)}`;
+      }).join("\n");
+      sections.push(`### Unread Messages
+${msgLines}`);
+    }
+  } catch {
+  }
+  return {
+    header: HEADER,
+    sections: clampSections(HEADER, sections, MAX_BRIEF_CHARS)
+  };
+}
+export {
+  buildCatchupBrief
+};

package/dist/chunk-22R3G3GD.js

@@ -0,0 +1,297 @@
+import {
+  EXE_AI_DIR
+} from "./chunk-CEKZ77KA.js";
+import {
+  atomicWriteJsonSync
+} from "./chunk-LYH5HE24.js";
+
+// src/lib/background-jobs.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+import { execFileSync } from "child_process";
+import os from "os";
+import path from "path";
+var JOB_DIR = path.join(EXE_AI_DIR, "jobs");
+var JOBS_FILE = path.join(JOB_DIR, "jobs.json");
+var LOCK_DIR = path.join(JOB_DIR, "locks");
+var DEFAULT_LOCK_TTL_MS = 6 * 60 * 60 * 1e3;
+var MAX_HISTORY = 200;
+function ensureDirs() {
+  mkdirSync(LOCK_DIR, { recursive: true });
+}
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function isAlive(pid) {
+  if (!pid || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readJobsRaw() {
+  ensureDirs();
+  if (!existsSync(JOBS_FILE)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync(JOBS_FILE, "utf8"));
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function writeJobsRaw(jobs) {
+  ensureDirs();
+  const running = jobs.filter((j) => j.status === "running");
+  const rest = jobs.filter((j) => j.status !== "running").slice(-MAX_HISTORY);
+  atomicWriteJsonSync(JOBS_FILE, [...rest, ...running]);
+}
+function listBackgroundJobs() {
+  const jobs = readJobsRaw();
+  let changed = false;
+  for (const job of jobs) {
+    if (job.status === "running" && !isAlive(job.pid)) {
+      job.status = "stale";
+      job.updatedAt = now();
+      changed = true;
+    }
+  }
+  if (changed) writeJobsRaw(jobs);
+  return jobs;
+}
+function lockPath(type) {
+  return path.join(LOCK_DIR, `${type.replace(/[^a-zA-Z0-9_.-]/g, "_")}.lock`);
+}
+function acquireJobLock(type, ttlMs = DEFAULT_LOCK_TTL_MS) {
+  ensureDirs();
+  const file = lockPath(type);
+  if (existsSync(file)) {
+    try {
+      const lock = JSON.parse(readFileSync(file, "utf8"));
+      const age = Date.now() - Date.parse(lock.updatedAt ?? "");
+      if (lock.pid && isAlive(lock.pid) && Number.isFinite(age) && age < ttlMs) return false;
+    } catch {
+    }
+    try {
+      unlinkSync(file);
+    } catch {
+    }
+  }
+  try {
+    writeFileSync(file, JSON.stringify({ pid: process.pid, updatedAt: now() }, null, 2) + "\n", { flag: "wx" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function releaseJobLock(type) {
+  const file = lockPath(type);
+  try {
+    if (!existsSync(file)) return;
+    const lock = JSON.parse(readFileSync(file, "utf8"));
+    if (lock.pid === process.pid || !lock.pid || !isAlive(lock.pid)) unlinkSync(file);
+  } catch (e) {
+    process.stderr.write("[bg-jobs] releaseJobLock read/parse: " + (e instanceof Error ? e.message : String(e)) + "\n");
+    try {
+      unlinkSync(file);
+    } catch {
+    }
+  }
+}
+function startManagedJob(options) {
+  const lowPriority = options.lowPriority ?? true;
+  if (!acquireJobLock(options.type, options.lockTtlMs)) return null;
+  if (lowPriority) {
+    try {
+      os.setPriority(process.pid, 10);
+    } catch {
+    }
+  }
+  const id = `${options.type}-${Date.now()}-${process.pid}`.replace(/[^a-zA-Z0-9_.-]/g, "_");
+  const record = {
+    id,
+    type: options.type,
+    name: options.name,
+    pid: process.pid,
+    command: options.command ?? process.argv.join(" "),
+    cwd: process.cwd(),
+    status: "running",
+    startedAt: now(),
+    updatedAt: now(),
+    lastHeartbeatAt: now(),
+    cancelCommand: `exe-os jobs cancel ${id}`,
+    lowPriority
+  };
+  const upsert = (patch) => {
+    const jobs = readJobsRaw().filter((j) => j.id !== id);
+    Object.assign(record, patch, { updatedAt: now() });
+    writeJobsRaw([...jobs, record]);
+    const file = lockPath(options.type);
+    try {
+      writeFileSync(file, JSON.stringify({ pid: process.pid, jobId: id, updatedAt: record.updatedAt }, null, 2) + "\n");
+    } catch {
+    }
+  };
+  upsert({});
+  const timer = setInterval(() => upsert({ lastHeartbeatAt: now() }), 3e4);
+  timer.unref?.();
+  const cleanup = (status, error) => {
+    clearInterval(timer);
+    upsert({ status, error, lastHeartbeatAt: now() });
+    releaseJobLock(options.type);
+  };
+  process.once("SIGTERM", () => {
+    cleanup("cancelled");
+    process.exit(0);
+  });
+  process.once("SIGINT", () => {
+    cleanup("cancelled");
+    process.exit(130);
+  });
+  process.once("exit", () => releaseJobLock(options.type));
+  return {
+    id,
+    update(progress) {
+      upsert({ progressCurrent: progress.current, progressTotal: progress.total, progressLabel: progress.label, lastHeartbeatAt: now() });
+    },
+    complete() {
+      cleanup("completed");
+    },
+    fail(err) {
+      cleanup("failed", err instanceof Error ? err.message : String(err));
+    },
+    cancel() {
+      cleanup("cancelled");
+    }
+  };
+}
+async function politeBatchPause(ms = 250) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+function cancelBackgroundJob(id) {
+  const jobs = listBackgroundJobs();
+  const job = jobs.find((j) => j.id === id || String(j.pid) === id);
+  if (!job) return null;
+  if (job.status === "running" && isAlive(job.pid)) {
+    try {
+      process.kill(job.pid, "SIGTERM");
+    } catch {
+    }
+  }
+  job.status = "cancelled";
+  job.updatedAt = now();
+  writeJobsRaw(jobs.map((j) => j.id === job.id ? job : j));
+  releaseJobLock(job.type);
+  return job;
+}
+function formatJobs(jobs = listBackgroundJobs()) {
+  if (jobs.length === 0) return "No exe-os background jobs found.";
+  const recent = [...jobs].sort((a, b) => b.startedAt.localeCompare(a.startedAt)).slice(0, 30);
+  const lines = ["EXE OS BACKGROUND JOBS", ""];
+  for (const job of recent) {
+    const progress = job.progressTotal ? ` ${job.progressCurrent ?? 0}/${job.progressTotal}` : job.progressCurrent != null ? ` ${job.progressCurrent}` : "";
+    lines.push(`${job.status === "running" ? "\u25CF" : "\u25CB"} ${job.name} [${job.status}]${progress}`);
+    lines.push(`  id: ${job.id}`);
+    lines.push(`  pid: ${job.pid}  started: ${job.startedAt}`);
+    if (job.progressLabel) lines.push(`  ${job.progressLabel}`);
+    if (job.status === "running") lines.push(`  cancel: exe-os jobs cancel ${job.id}`);
+    if (job.error) lines.push(`  error: ${job.error}`);
+  }
+  return lines.join("\n");
+}
+function reniceCurrentProcess(priority = 10) {
+  try {
+    os.setPriority(process.pid, priority);
+    return;
+  } catch {
+  }
+  try {
+    execFileSync("renice", [String(priority), "-p", String(process.pid)], { stdio: "ignore" });
+  } catch {
+  }
+}
+function readCpuPercent(pid) {
+  try {
+    const out = execFileSync("ps", ["-p", String(pid), "-o", "%cpu="], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    const cpu = Number.parseFloat(out);
+    return Number.isFinite(cpu) ? cpu : null;
+  } catch {
+    return null;
+  }
+}
+function renicePid(pid, priority = 15) {
+  try {
+    execFileSync("renice", [String(priority), "-p", String(pid)], { stdio: "ignore" });
+  } catch {
+  }
+}
+function enforceBackgroundJobGuardrails(options = {}) {
+  const reniceAt = options.reniceCpuPercent ?? 80;
+  const cancelAt = options.cancelCpuPercent ?? 180;
+  const cancelAfter = options.cancelAfterStrikes ?? 2;
+  const staleAfter = options.heartbeatStaleMs ?? 5 * 6e4;
+  const jobs = readJobsRaw();
+  const actions = [];
+  let changed = false;
+  const ts = now();
+  for (const job of jobs) {
+    if (job.status !== "running") continue;
+    if (!isAlive(job.pid)) {
+      job.status = "stale";
+      job.updatedAt = ts;
+      actions.push({ jobId: job.id, name: job.name, pid: job.pid, action: "marked-stale" });
+      changed = true;
+      continue;
+    }
+    const heartbeatAge = Date.now() - Date.parse(job.lastHeartbeatAt || job.updatedAt || job.startedAt);
+    if (Number.isFinite(heartbeatAge) && heartbeatAge > staleAfter) {
+      job.status = "stale";
+      job.updatedAt = ts;
+      actions.push({ jobId: job.id, name: job.name, pid: job.pid, action: "marked-stale" });
+      changed = true;
+      continue;
+    }
+    const cpu = readCpuPercent(job.pid);
+    if (cpu == null) continue;
+    job.lastCpuPercent = cpu;
+    if (cpu >= cancelAt) {
+      job.heatStrikes = (job.heatStrikes ?? 0) + 1;
+      if (job.heatStrikes >= cancelAfter) {
+        try {
+          process.kill(job.pid, "SIGTERM");
+        } catch {
+        }
+        job.status = "cancelled";
+        job.updatedAt = ts;
+        job.progressLabel = `Cancelled by heat guardrail after sustained high CPU (${cpu.toFixed(1)}%).`;
+        releaseJobLock(job.type);
+        actions.push({ jobId: job.id, name: job.name, pid: job.pid, action: "cancelled-hot", cpuPercent: cpu, heatStrikes: job.heatStrikes });
+        changed = true;
+        continue;
+      }
+    } else if (cpu < reniceAt / 2) {
+      job.heatStrikes = 0;
+    }
+    if (cpu >= reniceAt) {
+      renicePid(job.pid, 15);
+      job.updatedAt = ts;
+      job.progressLabel = `Throttled by heat guardrail (${cpu.toFixed(1)}% CPU).`;
+      actions.push({ jobId: job.id, name: job.name, pid: job.pid, action: "reniced", cpuPercent: cpu, heatStrikes: job.heatStrikes });
+      changed = true;
+    }
+  }
+  if (changed) writeJobsRaw(jobs);
+  return actions;
+}
+
+export {
+  listBackgroundJobs,
+  acquireJobLock,
+  releaseJobLock,
+  startManagedJob,
+  politeBatchPause,
+  cancelBackgroundJob,
+  formatJobs,
+  reniceCurrentProcess,
+  enforceBackgroundJobGuardrails
+};

package/dist/chunk-2CO47E5Q.js

@@ -0,0 +1,210 @@
+import {
+  redactSecrets
+} from "./chunk-Y25OJWOQ.js";
+
+// src/lib/memory-write-governor.ts
+import { createHash } from "crypto";
+var HIGH_VALUE_SUPERSESSION_TYPES = /* @__PURE__ */ new Set([
+  "decision",
+  "adr",
+  "behavior",
+  "procedure"
+]);
+var NOISE_DROP_PATTERNS = [
+  /^\s*\[📋\s+\d+\s+reviews?\s+pending\b/im,
+  /^\s*<system-reminder>[\s\S]*?<\/system-reminder>\s*$/im,
+  /^\s*The UserPromptSubmit hook checks the DB for new tasks/im,
+  /^\s*Intercom is a speedup, not delivery/im,
+  /^\s*Context bar reads as USAGE not remaining/im,
+  // Intercom noise — these repeat on every prompt and cause 18K+ duplicates
+  /^\/exe-intercom\b/i,
+  /^You have pending notifications\.\s*Run list_tasks/i,
+  /^You have open tasks\.\s*Run list_tasks/i,
+  /^You have a new P\d+ task/i,
+  /^You have more open tasks to dispatch/i,
+  /^No new tasks\.\s*(Standing by|Idle|Dashboard)/i
+];
+var SKIP_EMBED_PATTERNS = [
+  /tmux capture-pane\b/i,
+  /docker ps\b/i,
+  /docker images\b/i,
+  /git status\b/i,
+  /grep .*node_modules/i,
+  /npm (install|ci)\b[\s\S]*(added \d+ packages|audited \d+ packages)/i
+];
+function normalizeMemoryText(text) {
+  return text.replace(/\r\n/g, "\n").replace(/[ \t]+$/gm, "").replace(/\n{4,}/g, "\n\n\n").trim();
+}
+function classifyMemoryType(input) {
+  if (input.memory_type && input.memory_type.trim()) return input.memory_type.trim();
+  const tool = input.tool_name.toLowerCase();
+  const text = input.raw_text.toLowerCase();
+  if (tool.includes("store_decision") || tool.includes("decision")) return "decision";
+  if (tool.includes("commit") || text.includes("adr-") || text.includes("architectural decision")) return "adr";
+  if (tool.includes("store_behavior") || tool.includes("behavior")) return "behavior";
+  if (tool.includes("global_procedure") || text.includes("organization-wide procedures")) return "procedure";
+  if (tool.includes("checkpoint") || text.startsWith("context checkpoint")) return "checkpoint";
+  if (tool.includes("sessionsummary") || tool.includes("session-summary")) return "summary";
+  if (tool.includes("sessionend") || text.startsWith("session ended")) return "summary";
+  if (tool.includes("send_whatsapp") || tool.includes("conversation")) return "conversation";
+  if (tool === "store_memory" || tool === "manual") return "observation";
+  if (tool === "userprompt" || tool === "slashcommand") return "conversation";
+  return "raw";
+}
+function shouldDropMemory(text) {
+  const normalized = normalizeMemoryText(text);
+  if (normalized.length < 10) return { drop: true, reason: "too_short" };
+  if (NOISE_DROP_PATTERNS.some((pattern) => pattern.test(normalized))) {
+    return { drop: true, reason: "known_boilerplate_noise" };
+  }
+  return { drop: false };
+}
+function shouldSkipEmbedding(input) {
+  const type = classifyMemoryType(input);
+  if (HIGH_VALUE_SUPERSESSION_TYPES.has(type)) return false;
+  if (type === "raw" && input.raw_text.length > 2e4) return true;
+  if (SKIP_EMBED_PATTERNS.some((pattern) => pattern.test(input.raw_text))) return true;
+  return false;
+}
+function hashMemoryContent(text) {
+  return createHash("sha256").update(normalizeMemoryText(text)).digest("hex");
+}
+function scopedDedupArgs(input) {
+  return [input.contentHash, input.agentId, input.projectName, input.memoryType];
+}
+function governMemoryRecord(record) {
+  const redacted = redactSecrets(record.raw_text);
+  const normalized = normalizeMemoryText(redacted.text);
+  const memoryType = classifyMemoryType({
+    raw_text: normalized,
+    agent_id: record.agent_id,
+    project_name: record.project_name,
+    tool_name: record.tool_name,
+    memory_type: record.memory_type
+  });
+  const drop = shouldDropMemory(normalized);
+  const skipEmbedding = shouldSkipEmbedding({
+    raw_text: normalized,
+    agent_id: record.agent_id,
+    project_name: record.project_name,
+    tool_name: record.tool_name,
+    memory_type: memoryType
+  });
+  const trajectoryValue = record.trajectory;
+  const redactedTrajectory = typeof trajectoryValue === "string" ? redactSecrets(trajectoryValue).text : record.trajectory;
+  return {
+    record: {
+      ...record,
+      raw_text: normalized,
+      memory_type: memoryType,
+      vector: skipEmbedding ? null : record.vector,
+      keywords: record.keywords ? redactSecrets(record.keywords).text : record.keywords,
+      trajectory: redactedTrajectory
+    },
+    contentHash: hashMemoryContent(normalized),
+    shouldDrop: drop.drop,
+    dropReason: drop.reason,
+    skipEmbedding,
+    hygiene: {
+      dedup: true,
+      supersession: HIGH_VALUE_SUPERSESSION_TYPES.has(memoryType)
+    }
+  };
+}
+async function findScopedDuplicate(input) {
+  const { getClient } = await import("./lib/database.js");
+  const client = getClient();
+  const args = scopedDedupArgs(input);
+  let sql = `SELECT id FROM memories
+             WHERE content_hash = ?
+               AND agent_id = ?
+               AND project_name = ?
+               AND COALESCE(memory_type, 'raw') = ?
+               AND COALESCE(status, 'active') != 'deleted'`;
+  if (input.excludeId) {
+    sql += " AND id != ?";
+    args.push(input.excludeId);
+  }
+  sql += " ORDER BY timestamp DESC LIMIT 1";
+  const result = await client.execute({ sql, args });
+  return result.rows[0]?.id ? String(result.rows[0].id) : null;
+}
+async function runPostWriteMemoryHygiene(memoryId) {
+  try {
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    const current = await client.execute({
+      sql: `SELECT id, agent_id, project_name, memory_type, content_hash, supersedes_id,
+                   importance, timestamp
+            FROM memories
+            WHERE id = ?
+            LIMIT 1`,
+      args: [memoryId]
+    });
+    const row = current.rows[0];
+    if (!row) return;
+    const memoryType = String(row.memory_type ?? "raw");
+    const contentHash = row.content_hash ? String(row.content_hash) : null;
+    const agentId = String(row.agent_id);
+    const projectName = String(row.project_name);
+    if (contentHash) {
+      await client.execute({
+        sql: `UPDATE memories
+              SET status = 'deleted',
+                  outcome = COALESCE(outcome, 'superseded')
+              WHERE id != ?
+                AND content_hash = ?
+                AND agent_id = ?
+                AND project_name = ?
+                AND COALESCE(memory_type, 'raw') = ?
+                AND COALESCE(status, 'active') = 'active'`,
+        args: [memoryId, contentHash, agentId, projectName, memoryType]
+      });
+    }
+    const supersedesId = row.supersedes_id ? String(row.supersedes_id) : null;
+    if (supersedesId && HIGH_VALUE_SUPERSESSION_TYPES.has(memoryType)) {
+      const old = await client.execute({
+        sql: `SELECT importance FROM memories WHERE id = ? LIMIT 1`,
+        args: [supersedesId]
+      });
+      const oldImportance = Number(old.rows[0]?.importance ?? 0);
+      const newImportance = Number(row.importance ?? 0);
+      await client.batch([
+        {
+          sql: `UPDATE memories
+                SET status = 'archived',
+                    outcome = COALESCE(outcome, 'superseded')
+                WHERE id = ?`,
+          args: [supersedesId]
+        },
+        {
+          sql: `UPDATE memories
+                SET importance = MAX(COALESCE(importance, 5), ?),
+                    parent_memory_id = COALESCE(parent_memory_id, ?)
+                WHERE id = ?`,
+          args: [Math.max(oldImportance, newImportance), supersedesId, memoryId]
+        }
+      ], "write");
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[memory-governor] post-write hygiene failed for ${memoryId}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
+function schedulePostWriteMemoryHygiene(memoryIds) {
+  if (process.env.EXE_SKIP_MEMORY_HYGIENE === "1") return;
+  if (memoryIds.length === 0) return;
+  const run = () => {
+    void Promise.all(memoryIds.map((id) => runPostWriteMemoryHygiene(id)));
+  };
+  if (typeof setImmediate === "function") setImmediate(run);
+  else setTimeout(run, 0);
+}
+
+export {
+  governMemoryRecord,
+  findScopedDuplicate,
+  schedulePostWriteMemoryHygiene
+};