@askexenow/exe-os 0.9.384 → 0.9.389

package/dist/{chunk-3XY57PKT.js → chunk-KZLKE7I3.js}

@@ -1,3 +1,6 @@
+import {
+  isInertAssignment
+} from "./chunk-V6F4I2XY.js";
 import {
   MAIN_GUARD_OVERRIDE_ENV,
   MAIN_GUARD_OVERRIDE_TOKEN,
@@ -1613,78 +1616,237 @@ var LEDGER_READ_ONLY_PROGRAMS = /* @__PURE__ */ new Set([
 var TRUSTED_SYSTEM_BIN_DIRS = /* @__PURE__ */ new Set(["/bin", "/usr/bin", "/sbin", "/usr/sbin"]);
 function isTrustedAbsoluteProgramPath(tok, cwd) {
   if (!tok.includes("/")) return true;
-  let real;
+  const real = realResolve(cwd, tok);
+  if (real === null) return false;
+  return TRUSTED_SYSTEM_BIN_DIRS.has(path2.dirname(real));
+}
+function realResolve(cwd, p) {
+  let cur;
   try {
-    real = fs.realpathSync(path2.resolve(cwd, tok));
+    cur = path2.isAbsolute(p) ? path2.parse(path2.resolve(p)).root : realDir(path2.resolve(cwd));
   } catch {
-    return false;
+    return null;
+  }
+  for (const seg of p.split(/[\\/]+/)) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") {
+      cur = path2.dirname(cur);
+      continue;
+    }
+    cur = realDir(path2.join(cur, seg));
+  }
+  return cur;
+}
+function realDir(dir) {
+  try {
+    return fs.realpathSync.native(dir);
+  } catch {
+    return dir;
   }
-  return TRUSTED_SYSTEM_BIN_DIRS.has(path2.dirname(real));
 }
 function splitShellSegments2(command) {
   return command.split(/\|\||&&|[|;\n&]/).map((seg) => seg.trim()).filter((seg) => seg.length > 0);
 }
 function segmentProgram(segment, cwd) {
-  let pathOverridden = false;
   for (const tok of tokenizeShell(segment).tokens) {
     if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(tok)) {
-      if (/^PATH=/.test(tok)) pathOverridden = true;
+      if (!isInertAssignment(tok)) return "";
       continue;
     }
-    if (pathOverridden) return "";
     if (!isTrustedAbsoluteProgramPath(tok, cwd)) return "";
     return path2.basename(tok);
   }
   return "";
 }
-var LEDGER_RESOLVABLE_ENV_VARS = ["HOME", "EXE_GATEWAY_LEDGER_DIR", "EXE_OS_DIR"];
-function hasUnresolvedShellExpansion(token) {
-  const known = LEDGER_RESOLVABLE_ENV_VARS.join("|");
-  return new RegExp("\\$\\(|\\$\\{(?!(?:" + known + ")\\})|\\$(?!(?:" + known + ")\\b)[A-Za-z_]|`").test(token);
-}
-function expandKnownEnvReferences(token, homeDir, env) {
+var UNRESOLVABLE_EXPANSION = /\$\(|`|\$\{(?![A-Za-z_][A-Za-z0-9_]*\})|\$(?![A-Za-z_])/;
+function expandEnvReferences(token, homeDir, env) {
   const home = env.HOME ?? homeDir;
-  const values = {
-    HOME: home,
-    EXE_GATEWAY_LEDGER_DIR: env.EXE_GATEWAY_LEDGER_DIR,
-    // Mirrors resolveLedgerPath()'s own fallback chain exactly (ledger.ts).
-    EXE_OS_DIR: env.EXE_OS_DIR ?? path2.join(home, ".exe-os")
+  const lookup = (name) => {
+    if (name === "HOME") return home;
+    if (name === "EXE_OS_DIR") return env.EXE_OS_DIR ?? path2.join(home, ".exe-os");
+    return env[name] ?? "";
   };
-  let out = token;
-  for (const name of LEDGER_RESOLVABLE_ENV_VARS) {
-    const value = values[name];
-    if (value === void 0) continue;
-    out = out.replace(new RegExp(`\\$\\{${name}\\}`, "g"), value).replace(new RegExp(`\\$${name}\\b`, "g"), value);
-  }
+  let out = token.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_m, name) => lookup(name)).replace(/\$([A-Za-z_][A-Za-z0-9_]*)/g, (_m, name) => lookup(name));
   if (out === "~" || out.startsWith("~/")) out = home + out.slice(1);
   return out;
 }
-function commandMutatesLedger(command, ledgerPath, homeDir, cwd, env) {
-  const resolvedLedger = path2.resolve(ledgerPath);
-  const ledgerDir = path2.dirname(resolvedLedger);
-  const base = path2.basename(resolvedLedger);
-  const mentionsLedgerPath = (text) => text.includes(ledgerPath) || text.includes(base) || text.includes(ledgerDir);
-  const segmentNamesLedger = (text) => {
-    if (mentionsLedgerPath(text)) return true;
-    if (mentionsLedgerPath(expandKnownEnvReferences(text, homeDir, env))) return true;
-    return tokenizeShell(text).tokens.some((tok) => {
-      const stripped = tok.replace(/\/+\*+\/?$/, "");
-      const expanded = expandKnownEnvReferences(stripped, homeDir, env);
-      if (hasUnresolvedShellExpansion(expanded)) return false;
-      const resolved = path2.resolve(cwd, expanded);
-      return resolved === resolvedLedger || resolved === ledgerDir || resolved.startsWith(ledgerDir + path2.sep);
-    });
+function isUnverifiablePathToken(expanded) {
+  if (!UNRESOLVABLE_EXPANSION.test(expanded)) return false;
+  const residue = expanded.replace(/\$\([^)]*\)/g, "").replace(/`[^`]*`/g, "").replace(/\$\{[^}]*\}/g, "").replace(/\$[^A-Za-z_\s]/g, "");
+  return residue.includes("/") || residue.includes("~");
+}
+function inAuditDir(resolved, auditDir, ledgerFile) {
+  return resolved === ledgerFile || resolved === auditDir || resolved.startsWith(auditDir + path2.sep);
+}
+function globComponentPattern(component) {
+  let pattern = "";
+  for (let i = 0; i < component.length; i++) {
+    const char = component[i];
+    if (char === "*") pattern += ".*";
+    else if (char === "?") pattern += ".";
+    else if (char === "[") {
+      let start = i + 1;
+      const negated = component[start] === "!" || component[start] === "^";
+      if (negated) start++;
+      const end = component.indexOf("]", component[start] === "]" ? start + 1 : start);
+      if (end < 0) throw new Error("Unverified glob character class");
+      const chars = component.slice(start, end);
+      if (chars.includes("[") || chars.includes("\\")) throw new Error("Unverified glob character class");
+      pattern += `[${negated ? "^" : ""}${chars.replace(/[\]^]/g, "\\$&")}]`;
+      i = end;
+    } else pattern += char.replace(/[.+^${}()|\\\]]/g, "\\$&");
+  }
+  return new RegExp(`^${pattern}$`, "s");
+}
+function globDirectoryEntries(directory) {
+  try {
+    return fs.readdirSync(directory);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT" || code === "ENOTDIR") return [];
+    throw error;
+  }
+}
+function globAuditVerdict(expanded, cwd, auditDir, ledgerFile) {
+  let directories = [path2.isAbsolute(expanded) ? path2.parse(expanded).root : cwd];
+  let visited = 0;
+  const resolve = (directory, name) => {
+    if (++visited > 1e4) throw new Error("Unverified glob: traversal limit exceeded");
+    const resolved = realResolve(directory, name);
+    if (resolved === null) throw new Error("Unverified glob path");
+    return resolved;
   };
-  const namesLedgerLiterally = command.includes(ledgerPath) || command.includes(base) || command.includes(ledgerDir);
-  const namesLedgerResolved = segmentNamesLedger(command);
-  if (!namesLedgerLiterally && !namesLedgerResolved) return false;
-  const segments = splitShellSegments2(command);
-  const namingSegments = segments.filter((seg) => segmentNamesLedger(seg));
-  if (namingSegments.length === 0) return true;
-  return namingSegments.some((seg) => {
-    if (/[<>]/.test(seg)) return true;
-    return !LEDGER_READ_ONLY_PROGRAMS.has(segmentProgram(seg, cwd));
+  try {
+    for (const component of expanded.split("/")) {
+      if (!component) continue;
+      const next = /* @__PURE__ */ new Set();
+      if (component === "**") {
+        const pending = [...directories];
+        while (pending.length > 0) {
+          const directory = resolve(pending.pop(), ".");
+          if (inAuditDir(directory, auditDir, ledgerFile)) return "yes";
+          if (next.has(directory)) continue;
+          next.add(directory);
+          for (const name of globDirectoryEntries(directory)) pending.push(resolve(directory, name));
+        }
+        directories = [...next];
+        continue;
+      }
+      const pattern = /[*?\[]/.test(component) ? globComponentPattern(component) : null;
+      for (const directory of directories) {
+        const matches = pattern ? globDirectoryEntries(directory).filter((name) => pattern.test(name)) : [component];
+        for (const match of matches) {
+          const resolved = resolve(directory, match);
+          if (inAuditDir(resolved, auditDir, ledgerFile)) return "yes";
+          next.add(resolved);
+        }
+      }
+      directories = [...next];
+    }
+    return "no";
+  } catch {
+    return "unverified";
+  }
+}
+function segmentAuditVerdict(text, auditDir, ledgerFile, rawLedgerPath, rawAuditDir, homeDir, cwd, env) {
+  const mentions = (s) => s.includes(rawLedgerPath) || s.includes(rawAuditDir);
+  if (mentions(text) || mentions(expandEnvReferences(text, homeDir, env))) return "yes";
+  let unverified = false;
+  for (const frag of text.split(/\s+/)) {
+    if (isUnverifiablePathToken(expandEnvReferences(frag, homeDir, env))) unverified = true;
+  }
+  for (const tok of tokenizeShell(text).tokens) {
+    const stripped = tok.replace(/\/+\*+\/?$/, "");
+    const expanded = expandEnvReferences(stripped, homeDir, env);
+    if (isUnverifiablePathToken(expanded)) {
+      unverified = true;
+      continue;
+    }
+    if (UNRESOLVABLE_EXPANSION.test(expanded)) continue;
+    if (/[*?\[]/.test(expanded)) {
+      const verdict = globAuditVerdict(expanded, cwd, auditDir, ledgerFile);
+      if (verdict === "yes") return "yes";
+      if (verdict === "unverified") unverified = true;
+      continue;
+    }
+    const resolved = realResolve(cwd, expanded);
+    if (resolved === null) {
+      unverified = true;
+      continue;
+    }
+    if (inAuditDir(resolved, auditDir, ledgerFile)) return "yes";
+  }
+  for (const call of text.matchAll(/\.join\s*\(\s*((?:(?:"[^"\\]*"|'[^'\\]*')\s*,?\s*)+)\)/g)) {
+    const fragments = [...call[1].matchAll(/"([^"]*)"|'([^']*)'/g)].map((match) => expandEnvReferences(match[1] ?? match[2], homeDir, env));
+    if (fragments.some((fragment) => UNRESOLVABLE_EXPANSION.test(fragment))) {
+      unverified = true;
+      continue;
+    }
+    let lastAbsolute = 0;
+    fragments.forEach((fragment, index) => {
+      if (path2.isAbsolute(fragment)) lastAbsolute = index;
+    });
+    for (const joined of [path2.join(...fragments), fragments.slice(lastAbsolute).join("/")]) {
+      const resolved = realResolve(cwd, joined);
+      if (resolved === null) unverified = true;
+      else if (inAuditDir(resolved, auditDir, ledgerFile)) return "yes";
+    }
+  }
+  for (const frag of text.match(/[A-Za-z0-9_.~${}\/-]+/g) ?? []) {
+    if (!frag.includes("/")) continue;
+    const expanded = expandEnvReferences(frag.replace(/\/+\*+\/?$/, ""), homeDir, env);
+    if (UNRESOLVABLE_EXPANSION.test(expanded)) continue;
+    const resolved = realResolve(cwd, expanded);
+    if (resolved !== null && inAuditDir(resolved, auditDir, ledgerFile)) return "yes";
+  }
+  return unverified ? "unverified" : "no";
+}
+function commandMutatesLedger(command, ledgerPath, homeDir, cwd, env, depth = 0) {
+  const rawLedgerPath = path2.resolve(ledgerPath);
+  const rawAuditDir = path2.dirname(rawLedgerPath);
+  const auditDir = realResolve(cwd, rawAuditDir) ?? rawAuditDir;
+  const ledgerFile = realResolve(cwd, rawLedgerPath) ?? rawLedgerPath;
+  const verdictOf = (text, directory = cwd) => segmentAuditVerdict(text, auditDir, ledgerFile, rawLedgerPath, rawAuditDir, homeDir, directory, env);
+  if (depth > 8) return true;
+  const segments = splitShellSegments(command).flatMap((segment) => {
+    const tokens = tokenizeShell(segment).tokens;
+    return tokens.some((_token, index) => shellDashCScriptIndex(tokens, index) >= 0) ? [segment] : splitShellSegments2(segment);
   });
+  if (segments.length === 0) return verdictOf(command) !== "no";
+  let accountedFor = false;
+  const directories = /* @__PURE__ */ new Set([cwd]);
+  let unknownDirectory = false;
+  for (const seg of segments) {
+    const tokens = tokenizeShell(seg).tokens;
+    for (let index = 0; index < tokens.length; index++) {
+      const scriptIndex = shellDashCScriptIndex(tokens, index);
+      if (scriptIndex < 0) continue;
+      if (unknownDirectory || [...directories].some((directory) => commandMutatesLedger(tokens[scriptIndex], ledgerPath, homeDir, directory, env, depth + 1))) return true;
+    }
+    const changesDirectory = ["cd", "pushd", "popd"].includes(tokens[0] ?? "");
+    if (changesDirectory && /\$\(|`/.test(seg)) return true;
+    if (changesDirectory && !/[<>]/.test(seg)) {
+      accountedFor ||= [...directories].some((directory) => verdictOf(seg, directory) !== "no");
+      const target = expandEnvReferences(tokens[1] ?? "~", homeDir, env);
+      if (tokens[0] !== "cd" || tokens.length > 2 || target.startsWith("-") || UNRESOLVABLE_EXPANSION.test(target) || /[*?\[]/.test(target)) {
+        unknownDirectory = true;
+      } else {
+        for (const directory of [...directories]) {
+          const resolved = realResolve(directory, target);
+          if (resolved === null) unknownDirectory = true;
+          else directories.add(resolved);
+        }
+      }
+      continue;
+    }
+    const verdicts = [...directories].map((directory) => verdictOf(seg, directory));
+    const verdict = verdicts.includes("yes") ? "yes" : unknownDirectory || verdicts.includes("unverified") ? "unverified" : "no";
+    if (verdict === "no") continue;
+    accountedFor = true;
+    if (!/[<>]/.test(seg) && [...directories].every((directory) => LEDGER_READ_ONLY_PROGRAMS.has(segmentProgram(seg, directory)))) continue;
+    return true;
+  }
+  return !accountedFor && verdictOf(command) === "yes";
 }
 var ACTION_POLICY = [
   {

package/dist/{chunk-DYVLEMKS.js → chunk-L3GXMYBK.js}

@@ -1,6 +1,6 @@
 import {
   processCRMEvent
-} from "./chunk-P2VVMGMI.js";
+} from "./chunk-V4WH3FV7.js";
 
 // src/gateway/adapters/crm-webhook.ts
 function parseTwentyWebhook(payload) {

package/dist/{chunk-72V3S44T.js → chunk-LUA4SLJY.js}

@@ -466,7 +466,7 @@ async function createBackupAsync(reason = "manual", opts = {}) {
   let artifactState = "not-checked";
   let artifactDetail = "artifact read-back did not run";
   try {
-    const { manifestWriteEnabled, readBackBackupArtifact, manifestPathFor } = await import("./backup-verify-6DVBQMDP.js");
+    const { manifestWriteEnabled, readBackBackupArtifact, manifestPathFor } = await import("./backup-verify-TUQEICWA.js");
     if (manifestWriteEnabled()) {
       const readback = await readBackBackupArtifact(backupPath, dbName, { keyHex: encryptionKey });
       artifactState = readback.artifact;
@@ -694,7 +694,7 @@ function recordMissedBackup(entry) {
 function alertMissedBackup(message, skipped) {
   void (async () => {
     try {
-      const { pushNotifyAsync } = await import("./push-notifications-M7YU63FY.js");
+      const { pushNotifyAsync } = await import("./push-notifications-XC6EQEXF.js");
       pushNotifyAsync({
         event: "backup_failed",
         title: skipped ? "Backup SKIPPED \u2014 disk full" : "Backup FAILED \u2014 disk full",
@@ -833,6 +833,16 @@ function backupSizeCapBytes() {
   }
   return Math.max(3 * currentDbSize, DEFAULT_BACKUP_SIZE_CAP_FLOOR_BYTES);
 }
+function backupVerifiedProbe(backupPath) {
+  try {
+    statSync(backupPath + ".manifest.json");
+    return true;
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT" || code === "ENOTDIR") return false;
+    return null;
+  }
+}
 function enforceSizeRetention() {
   if (!existsSync(BACKUP_DIR)) return 0;
   let deleted = 0;
@@ -843,16 +853,21 @@ function enforceSizeRetention() {
       if (!file.endsWith(".db")) continue;
       if (reasonFromBackupName(file) === null) continue;
       const filePath = path.join(BACKUP_DIR, file);
+      let st;
       try {
-        const st = statSync(filePath);
-        backups.push({
-          path: filePath,
-          mtimeMs: st.mtimeMs,
-          sizeBytes: st.size,
-          verified: existsSync(filePath + ".manifest.json")
-        });
+        st = statSync(filePath);
       } catch {
+        continue;
       }
+      const verified = backupVerifiedProbe(filePath);
+      if (verified === null) {
+        process.stderr.write(
+          `[db-backup] size retention SKIPPED this pass \u2014 could not determine whether ${path.basename(filePath)} is verified, and an unverified-by-default list would strip the newest verified backup of its protection.
+`
+        );
+        return 0;
+      }
+      backups.push({ path: filePath, mtimeMs: st.mtimeMs, sizeBytes: st.size, verified });
     }
     for (const target of selectBackupsToDeleteBySize(backups, backupSizeCapBytes())) {
       for (const p of [target, target + "-wal", target + "-shm", target + ".manifest.json"]) {
@@ -952,20 +967,32 @@ function cleanupCrashDebris() {
 }
 function listBackups() {
   if (!existsSync(BACKUP_DIR)) return [];
-  try {
-    const files = readdirSync(BACKUP_DIR).filter((f) => f.endsWith(".db") && !f.endsWith(".tmp") && !f.endsWith("-wal") && !f.endsWith("-shm"));
-    return files.map((name) => {
-      const p = path.join(BACKUP_DIR, name);
-      const stat = statSync(p);
-      return { path: p, name, size: stat.size, date: stat.mtime };
-    }).sort((a, b) => b.date.getTime() - a.date.getTime());
-  } catch {
-    return [];
+  const files = readdirSync(BACKUP_DIR).filter((f) => f.endsWith(".db") && !f.endsWith(".tmp") && !f.endsWith("-wal") && !f.endsWith("-shm"));
+  const found = [];
+  for (const name of files) {
+    const p = path.join(BACKUP_DIR, name);
+    let stat;
+    try {
+      stat = statSync(p);
+    } catch (e) {
+      if (e.code === "ENOENT") continue;
+      throw new Error(
+        `backup inventory is incomplete: ${p} could not be stat'ed (${e.code ?? "unknown"}). Refusing to report a partial backup list as the whole one.`,
+        { cause: e }
+      );
+    }
+    found.push({ path: p, name, size: stat.size, date: stat.mtime });
   }
+  return found.sort((a, b) => b.date.getTime() - a.date.getTime());
 }
 function hasBackupToday(reason) {
   const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const backups = listBackups();
+  let backups;
+  try {
+    backups = listBackups();
+  } catch {
+    return false;
+  }
   return backups.some((b) => b.name.includes(reason) && b.name.includes(today.replace(/-/g, "-")));
 }
 var DEFAULT_PRE_RESTART_DEDUP_MS = 30 * 60 * 1e3;

package/dist/{chunk-ZT4LFTUJ.js → chunk-LW3JCBXP.js}

@@ -2,7 +2,7 @@ import {
   getClient,
   isCoordinatorName,
   loadEmployeesSync
-} from "./chunk-GL47M7NY.js";
+} from "./chunk-3UD3OF3X.js";
 
 // src/lib/steward-gate.ts
 import crypto from "crypto";
@@ -54,9 +54,11 @@ var StewardGate = class {
     let reason;
     if (!allowed && role === "specialist" && operation === "deactivate_behavior") {
       const isOwn = await this.isOwnBehavior(agent, target);
-      if (isOwn) {
+      if (isOwn === true) {
         allowed = true;
         reason = `Specialist "${agent}" can deactivate their own behavior.`;
+      } else if (isOwn === null) {
+        reason = `Ownership of behavior "${target}" could not be verified \u2014 the behaviors table could not be read (database locked, unreachable, or opened with the wrong key). Denying because unverified ownership is not ownership; this is NOT a finding that the behavior belongs to another agent. Fix the database access and retry.`;
       } else {
         reason = `Specialist "${agent}" cannot deactivate behaviors belonging to other agents.`;
       }
@@ -170,6 +172,21 @@ var StewardGate = class {
   }
   /**
    * Check if a behavior belongs to the given agent.
+   *
+   * THREE-VALUED. `null` means "I could not check" — a DB lock, a wrong
+   * SQLCipher key, a missing `behaviors` table. It is NOT `false`.
+   *
+   * Bug d11c5049 (catch-as-absence sweep, finding C6). The catch used to
+   * return `false`, which is the correct fail-CLOSED direction and stays that
+   * way — but the caller turns `false` into
+   *
+   *   Specialist "X" cannot deactivate behaviors belonging to other agents
+   *
+   * and told that to a specialist whose behavior it IS, because the database
+   * was unreachable. The denial was right; the reason was a fabrication, and it
+   * aims the operator at a permissions problem instead of at their database.
+   * The reference pattern for this is prompt-submit.ts:281 — `null` as a
+   * distinct third state, with the decision unchanged.
    */
   async isOwnBehavior(agent, behaviorId) {
     try {
@@ -181,7 +198,7 @@ var StewardGate = class {
       if (result.rows.length === 0) return false;
       return String(result.rows[0].agent_id) === agent;
     } catch {
-      return false;
+      return null;
     }
   }
   /**

package/dist/{chunk-YLB365YX.js → chunk-M5XHN4OM.js}

@@ -8,14 +8,14 @@ import {
   resolveExeSession,
   sendIntercom,
   strictSessionScopeFilter
-} from "./chunk-7UHZBVP3.js";
+} from "./chunk-QDVLVLXP.js";
 import {
   parseMessage,
   serializeMessage
 } from "./chunk-TDF2XKLK.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-LSNBTGW4.js";
+} from "./chunk-DPYZW42H.js";
 import {
   getSessionKey
 } from "./chunk-CVYC6DUW.js";
@@ -24,7 +24,7 @@ import {
 } from "./chunk-BTSWFMEH.js";
 import {
   getClient
-} from "./chunk-GL47M7NY.js";
+} from "./chunk-3UD3OF3X.js";
 
 // src/lib/messaging.ts
 import crypto from "crypto";

package/dist/{chunk-VHHX4UCP.js → chunk-MDTWARSF.js}

@@ -3,7 +3,10 @@ import {
 } from "./chunk-5MOYSU5A.js";
 import {
   redactSecrets
-} from "./chunk-ELEGH4DX.js";
+} from "./chunk-ZUGQPYUY.js";
+import {
+  memoryDuplicatePredicate
+} from "./chunk-RBQUXHYK.js";
 
 // src/lib/memory-write-governor.ts
 import { createHash } from "crypto";
@@ -72,25 +75,26 @@ function shouldSkipEmbedding(input) {
 function hashMemoryContent(text) {
   return createHash("sha256").update(normalizeMemoryText(text)).digest("hex");
 }
+function dedupPredicate(input) {
+  return memoryDuplicatePredicate({
+    content_hash: input.contentHash,
+    agent_id: input.agentId,
+    project_name: input.projectName,
+    memory_type: input.memoryType,
+    session_scope: input.sessionScope ?? null,
+    workspace_id: input.workspaceId ?? null,
+    user_id: input.userId ?? null,
+    supersedes_id: input.supersedesId ?? null,
+    draft: input.draft ? 1 : 0
+  });
+}
 function scopedDedupArgs(input) {
-  return [input.contentHash, input.agentId, input.projectName, input.memoryType];
+  return dedupPredicate(input).args;
 }
 function scopedDedupSql(excludeId = false) {
-  let sql = `SELECT id FROM memories
-             WHERE content_hash = ?
-               -- Bug d23040c2: force SQLite away from idx_memories_agent_ts.
-               -- The old agent_id predicate plus ORDER BY timestamp DESC made
-               -- non-duplicate writes walk every row for the agent
-               -- (idx_memories_agent_ts; 1477ms on 60K rows). Unary plus keeps
-               -- the predicate semantics identical while disqualifying the
-               -- agent indexes, so the planner uses idx_memories_content_hash
-               -- (content_hash, agent_id); measured 0.03ms.
-               AND +agent_id = ?
-               AND project_name = ?
-               AND COALESCE(memory_type, 'raw') = ?
-               AND COALESCE(status, 'active') != 'deleted'`;
-  if (excludeId) sql += " AND id != ?";
-  return `${sql} ORDER BY timestamp DESC LIMIT 1`;
+  const predicate = dedupPredicate({ contentHash: "", agentId: "", projectName: "", memoryType: "raw" });
+  return `SELECT id FROM memories WHERE ${predicate.sql}${excludeId ? " AND id != ?" : ""}
+    ORDER BY timestamp DESC, id DESC LIMIT 1`;
 }
 function governMemoryRecord(record) {
   const redacted = redactSecrets(record.raw_text);
@@ -143,84 +147,9 @@ async function findScopedDuplicate(input) {
   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 {
   hashMemoryContent,
   governMemoryRecord,
-  findScopedDuplicate,
-  runPostWriteMemoryHygiene,
-  schedulePostWriteMemoryHygiene
+  findScopedDuplicate
 };

package/dist/{chunk-JFJP6ATJ.js → chunk-MWKXQSF6.js}

@@ -1,6 +1,6 @@
 import {
   isExeSession
-} from "./chunk-7UHZBVP3.js";
+} from "./chunk-QDVLVLXP.js";
 import {
   loadConfigSync
 } from "./chunk-MMS2HBRT.js";
@@ -17,7 +17,8 @@ var DEFAULT_NOTIFY_ON = [
   "context_full",
   "error_spike",
   "daemon_crash",
-  "review_ready"
+  "review_ready",
+  "hooks_dead"
 ];
 var _cachedConfig = null;
 var _notifyOn = null;

package/dist/{chunk-VJEJ7JNB.js → chunk-N32DVIKY.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-GL47M7NY.js";
+} from "./chunk-3UD3OF3X.js";
 
 // src/lib/skill-refinement.ts
 import crypto from "crypto";