open-walnut 0.3.0

package/dist/hooks/on-stop.js

@@ -0,0 +1,1329 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/hooks/shared.ts
+import fs3 from "fs";
+import path3 from "path";
+
+// src/constants.ts
+import path from "path";
+import fs from "fs";
+import os from "os";
+import { fileURLToPath } from "url";
+var WALNUT_HOME = resolveOpenWalnutHome();
+var IS_EPHEMERAL = process.argv.includes("--_ephemeral-child");
+var CLOUD_MODE = process.env.WALNUT_CLOUD_MODE === "1";
+function resolveOpenWalnutHome() {
+  const envHome = process.env.OPEN_WALNUT_HOME;
+  const productionHome = path.join(os.homedir(), ".open-walnut");
+  const isTestEnv = !!(process.env.VITEST || process.env.VITEST_WORKER_ID || process.env.NODE_ENV === "test");
+  if (isTestEnv) {
+    if (envHome && envHome !== productionHome && !envHome.startsWith(productionHome + path.sep)) {
+      assertNotProductionPath(envHome);
+      return envHome;
+    }
+    const testHome = path.join(os.tmpdir(), `open-walnut-test-${process.pid}`);
+    process.env.OPEN_WALNUT_HOME = testHome;
+    return testHome;
+  }
+  if (!envHome) return productionHome;
+  if (process.argv.includes("--_ephemeral-child")) return envHome;
+  if (isEphemeralTmpDir(envHome)) {
+    process.stderr.write(
+      `WARNING: OPEN_WALNUT_HOME=${envHome} looks like a leaked ephemeral temp dir.
+  Overriding to ${productionHome}. (Only --_ephemeral-child processes may use one.)
+`
+    );
+    process.env.OPEN_WALNUT_HOME = productionHome;
+    return productionHome;
+  }
+  return envHome;
+}
+function assertNotProductionPath(inputPath) {
+  const isTestEnv = !!(process.env.VITEST || process.env.VITEST_WORKER_ID || process.env.NODE_ENV === "test");
+  if (!isTestEnv) return;
+  const resolved = path.resolve(inputPath);
+  const prodHome = path.join(os.homedir(), ".open-walnut");
+  if (resolved === prodHome || resolved.startsWith(prodHome + path.sep)) {
+    throw new Error(
+      `SAFETY: Test process attempted to use production path: ${resolved}
+  This would destroy real user data in ~/.open-walnut/.
+  Set OPEN_WALNUT_HOME to a temp directory or let constants.ts auto-assign one.`
+    );
+  }
+}
+function isEphemeralTmpDir(inputPath) {
+  if (!/[\\/]open-walnut-[^\\/]+$/.test(inputPath)) return false;
+  const tmpDirs = /* @__PURE__ */ new Set();
+  tmpDirs.add(os.tmpdir());
+  try {
+    tmpDirs.add(fs.realpathSync(os.tmpdir()));
+  } catch {
+  }
+  try {
+    tmpDirs.add(fs.realpathSync("/tmp"));
+  } catch {
+  }
+  const parent = path.dirname(path.resolve(inputPath));
+  if (tmpDirs.has(parent)) return true;
+  try {
+    return tmpDirs.has(fs.realpathSync(parent));
+  } catch {
+    return false;
+  }
+}
+var TASKS_DIR = path.join(WALNUT_HOME, "tasks");
+var TASKS_FILE = path.join(TASKS_DIR, "tasks.json");
+var ARCHIVE_DIR = path.join(TASKS_DIR, "archive");
+var MEMORY_DIR = path.join(WALNUT_HOME, "memory");
+var SESSIONS_DIR = path.join(MEMORY_DIR, "sessions");
+var PROJECTS_DIR = path.join(MEMORY_DIR, "projects");
+var CONFIG_FILE = path.join(WALNUT_HOME, "config.yaml");
+var SYNC_DIR = path.join(WALNUT_HOME, "sync");
+var PLUGIN_STORES_DIR = path.join(WALNUT_HOME, "plugin-stores");
+var SESSIONS_FILE = path.join(WALNUT_HOME, "sessions.json");
+var CLAUDE_HOME = path.join(os.homedir(), ".claude");
+var HISTORY_CACHE_DIR = path.join(WALNUT_HOME, "cache", "history");
+var PROJECTION_CACHE_DIR = path.join(WALNUT_HOME, "cache", "projections");
+var TRANSCRIPT_CACHE_DIR = path.join(WALNUT_HOME, "cache", "transcripts");
+var TASK_QUEUE_DIR = path.join(WALNUT_HOME, "cache", "task-queue");
+var HOST_MODEL_CATALOG_FILE = path.join(WALNUT_HOME, "cache", "host-model-catalogs.json");
+var HOOK_LOG_FILE = path.join(WALNUT_HOME, "hook-errors.log");
+var DAILY_DIR = path.join(MEMORY_DIR, "daily");
+var MEMORY_FILE = path.join(MEMORY_DIR, "MEMORY.md");
+var USER_FILE = path.join(MEMORY_DIR, "USER.md");
+var LEGACY_MEMORY_FILE = path.join(WALNUT_HOME, "MEMORY.md");
+var PROJECTS_MEMORY_DIR = path.join(MEMORY_DIR, "projects");
+var CHAT_HISTORY_FILE = path.join(WALNUT_HOME, "chat-history.json");
+var CONVERSATIONS_DIR = path.join(WALNUT_HOME, "conversations");
+function agentDailyDir(agentId) {
+  if (!agentId || agentId === "general") return DAILY_DIR;
+  return path.join(MEMORY_DIR, "agents", agentId, "daily");
+}
+var GLOBAL_SKILLS_DIR = path.join(WALNUT_HOME, "skills");
+var SKILL_SETTINGS_FILE = path.join(WALNUT_HOME, "skill-settings.json");
+var CLAUDE_SKILLS_DIR = path.join(CLAUDE_HOME, "skills");
+var CLAUDE_SETTINGS_FILE = path.join(CLAUDE_HOME, "settings.json");
+var CLAUDE_PLUGINS_DIR = path.join(CLAUDE_HOME, "plugins");
+var CLAUDE_CREDENTIALS_FILE = path.join(CLAUDE_HOME, ".credentials.json");
+var CRON_FILE = path.join(WALNUT_HOME, "cron-jobs.json");
+var USAGE_DB_FILE = path.join(WALNUT_HOME, "usage.sqlite");
+var LOG_DIR = process.env.WALNUT_DAEMON_DIR || "/tmp/open-walnut";
+var SESSION_STREAMS_DIR = path.join(LOG_DIR, "streams");
+var DTACH_SOCKET_DIR = path.join(LOG_DIR, "term");
+var SESSION_QUEUE_FILE = path.join(WALNUT_HOME, "session-message-queue.json");
+var IMAGES_DIR = path.join(LOG_DIR, "images");
+var REMOTE_IMAGES_DIR = path.join(IMAGES_DIR, "remote");
+var PASTES_DIR = path.join(LOG_DIR, "pastes");
+var HEARTBEAT_FILE = path.join(WALNUT_HOME, "HEARTBEAT.md");
+var COMMANDS_DIR = path.join(WALNUT_HOME, "commands");
+var BUILTIN_COMMANDS_DIR = (() => {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 5; i++) {
+    const candidate = path.join(dir, "data", "slash-commands");
+    try {
+      if (fs.statSync(candidate).isDirectory()) return candidate;
+    } catch {
+    }
+    dir = path.dirname(dir);
+  }
+  return path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "data", "slash-commands");
+})();
+var BUILTIN_SKILLS_DIR = (() => {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 5; i++) {
+    const candidate = path.join(dir, "data", "skills");
+    try {
+      if (fs.statSync(candidate).isDirectory()) return candidate;
+    } catch {
+    }
+    dir = path.dirname(dir);
+  }
+  return path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "data", "skills");
+})();
+var FREQUENT_DIRS_FILE = path.join(WALNUT_HOME, "frequent-directories.json");
+var MENTION_DIRS_FILE = path.join(WALNUT_HOME, "mention-directories.json");
+var NOTES_DIR = path.join(WALNUT_HOME, "notes");
+var GLOBAL_NOTES_FILE = path.join(NOTES_DIR, "global-notes.md");
+var NOTES_AGENTS_FILE = path.join(NOTES_DIR, "AGENTS.md");
+var NOTES_CLAUDE_FILE = path.join(NOTES_DIR, "CLAUDE.md");
+var REPOSITORIES_DIR = path.join(WALNUT_HOME, "repositories");
+var REPOS_MEMORY_DIR = path.join(GLOBAL_SKILLS_DIR, "repos");
+var TOPICS_DIR = path.join(MEMORY_DIR, "topics");
+var COMPACTION_DIR = path.join(MEMORY_DIR, "compaction");
+var MEMORY_INDEX_FILE = path.join(MEMORY_DIR, "index.md");
+var WORKING_MEMORY_FILE = path.join(MEMORY_DIR, "working-memory.md");
+var TIMELINE_DIR = path.join(WALNUT_HOME, "timeline");
+var CONFIG_SHARE_DIR = path.join(WALNUT_HOME, "config", "share");
+var UI_PREFS_FILE = path.join(CONFIG_SHARE_DIR, "ui-prefs.json");
+var STT_VOCAB_FILE = path.join(CONFIG_SHARE_DIR, "stt-vocab.txt");
+var TMP_DIR = path.join(WALNUT_HOME, "tmp");
+var RECORDINGS_DIR = path.join(TMP_DIR, "recordings");
+var LOG_PREFIX = "open-walnut-";
+var DAEMON_BINARIES_DIR = (() => {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 5; i++) {
+    const candidate = path.join(dir, "dist", "daemon-binaries");
+    try {
+      if (fs.statSync(candidate).isDirectory()) return candidate;
+    } catch {
+    }
+    dir = path.dirname(dir);
+  }
+  return path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "dist", "daemon-binaries");
+})();
+var WALNUT_INSTALL_DIR = (() => {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 6; i++) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8"));
+      if (pkg.name === "open-walnut" && fs.statSync(path.join(dir, ".git")).isDirectory()) return dir;
+    } catch {
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+})();
+
+// src/logging/logger.ts
+import fs2 from "fs";
+import fsp from "fs/promises";
+import path2 from "path";
+
+// src/logging/redact.ts
+var REDACTED = "[REDACTED]";
+var patterns = [
+  // PEM private key blocks (multiline)
+  {
+    re: /-----BEGIN\s[\w\s]*PRIVATE KEY-----[\s\S]*?-----END\s[\w\s]*PRIVATE KEY-----/g,
+    replacement: REDACTED
+  },
+  // Bearer tokens: Authorization: Bearer <token>
+  {
+    re: /(Bearer\s+)\S+/gi,
+    replacement: `$1${REDACTED}`
+  },
+  // OpenAI / Anthropic style keys: sk-... (at least 20 chars after prefix)
+  {
+    re: /\bsk-[A-Za-z0-9_-]{20,}\b/g,
+    replacement: REDACTED
+  },
+  // AWS access key IDs: AKIA...
+  {
+    re: /\bAKIA[A-Z0-9]{12,}\b/g,
+    replacement: REDACTED
+  },
+  // AWS secret access key in key=value form
+  {
+    re: /(aws_secret_access_key\s*[=:]\s*)\S+/gi,
+    replacement: `$1${REDACTED}`
+  },
+  // AWS session token in key=value form
+  {
+    re: /(aws_session_token\s*[=:]\s*)\S+/gi,
+    replacement: `$1${REDACTED}`
+  },
+  // Credentials in URL userinfo: https://user:secret@host/...
+  // Motivating shape: execSync embeds the whole command in error.message, so a
+  // failed `git remote add origin https://walnut:<device-token>@host/git/data`
+  // otherwise logs the cloud companion's long-lived credential verbatim.
+  {
+    re: /(https?:\/\/[^/\s:@]+:)[^@/\s]+@/gi,
+    replacement: `$1${REDACTED}@`
+  },
+  // Generic secrets: password=, secret=, token=, api_key=, apikey=
+  {
+    re: /((?:password|secret|token|api_key|apikey)\s*[=:]\s*)\S+/gi,
+    replacement: `$1${REDACTED}`
+  }
+];
+function redactSensitiveText(text) {
+  let result = text;
+  for (const { re, replacement } of patterns) {
+    result = result.replace(re, replacement);
+  }
+  return result;
+}
+
+// src/logging/logger.ts
+var dirEnsured = false;
+function ensureLogDir() {
+  if (dirEnsured) return;
+  try {
+    fs2.mkdirSync(LOG_DIR, { recursive: true });
+    dirEnsured = true;
+  } catch {
+  }
+}
+function todayFileName() {
+  const d = /* @__PURE__ */ new Date();
+  const yyyy = d.getFullYear();
+  const mm = String(d.getMonth() + 1).padStart(2, "0");
+  const dd = String(d.getDate()).padStart(2, "0");
+  return `${LOG_PREFIX}${yyyy}-${mm}-${dd}.log`;
+}
+function logFilePath() {
+  return path2.join(LOG_DIR, todayFileName());
+}
+var FLUSH_INTERVAL_MS = 2e3;
+var buffer = [];
+var flushTimer = null;
+var flushing = false;
+function startFlushTimer() {
+  if (flushTimer) return;
+  flushTimer = setInterval(() => {
+    void flushLogBuffer();
+  }, FLUSH_INTERVAL_MS);
+  if (flushTimer && typeof flushTimer === "object" && "unref" in flushTimer) {
+    flushTimer.unref();
+  }
+}
+async function flushLogBuffer() {
+  if (flushing || buffer.length === 0) return;
+  flushing = true;
+  const batch = buffer;
+  buffer = [];
+  try {
+    ensureLogDir();
+    await fsp.appendFile(logFilePath(), batch.join(""), "utf-8");
+  } catch {
+  } finally {
+    flushing = false;
+  }
+}
+function flushLogBufferSync() {
+  if (buffer.length === 0) return;
+  const batch = buffer;
+  buffer = [];
+  try {
+    ensureLogDir();
+    fs2.appendFileSync(logFilePath(), batch.join(""), "utf-8");
+  } catch {
+  }
+}
+process.on("beforeExit", flushLogBufferSync);
+process.on("exit", flushLogBufferSync);
+function writeLogEntry(entry) {
+  const line = redactSensitiveText(JSON.stringify(entry)) + "\n";
+  buffer.push(line);
+  startFlushTimer();
+}
+
+// src/logging/subsystem.ts
+import chalk from "chalk";
+
+// src/logging/levels.ts
+var LOG_LEVEL_ORDER = {
+  trace: 0,
+  debug: 1,
+  info: 2,
+  warn: 3,
+  error: 4,
+  fatal: 5
+};
+var DEFAULT_LEVEL = "info";
+function resolveConfiguredLevel() {
+  const raw = process.env.WALNUT_LOG_LEVEL?.toLowerCase().trim();
+  if (raw && raw in LOG_LEVEL_ORDER) return raw;
+  return DEFAULT_LEVEL;
+}
+var CONFIGURED_LOG_LEVEL = resolveConfiguredLevel();
+function shouldLog(messageLevel, configuredLevel = CONFIGURED_LOG_LEVEL) {
+  return LOG_LEVEL_ORDER[messageLevel] >= LOG_LEVEL_ORDER[configuredLevel];
+}
+
+// src/logging/subsystem.ts
+var levelColor = {
+  trace: chalk.gray,
+  debug: chalk.cyan,
+  info: chalk.green,
+  warn: chalk.yellow,
+  error: chalk.red,
+  fatal: chalk.bgRed.white
+};
+var levelLabel = {
+  trace: "TRC",
+  debug: "DBG",
+  info: "INF",
+  warn: "WRN",
+  error: "ERR",
+  fatal: "FTL"
+};
+function timeStamp(d) {
+  const hh = String(d.getHours()).padStart(2, "0");
+  const mm = String(d.getMinutes()).padStart(2, "0");
+  const ss = String(d.getSeconds()).padStart(2, "0");
+  return `${hh}:${mm}:${ss}`;
+}
+function formatMeta(meta) {
+  if (!meta || Object.keys(meta).length === 0) return "";
+  return " " + chalk.dim(JSON.stringify(meta));
+}
+var ERROR_SINK_KEY = /* @__PURE__ */ Symbol.for("open-walnut.errorNotificationSink");
+var inErrorSink = false;
+function forwardToErrorSink(subsystem, message, meta) {
+  const sink = globalThis[ERROR_SINK_KEY];
+  if (!sink || inErrorSink) return;
+  if (subsystem.startsWith("notif")) return;
+  inErrorSink = true;
+  try {
+    sink({ subsystem, message, meta });
+  } catch {
+  } finally {
+    inErrorSink = false;
+  }
+}
+function emit(level, subsystem, message, meta) {
+  if (!shouldLog(level)) return;
+  const now = /* @__PURE__ */ new Date();
+  writeLogEntry({
+    time: now.toISOString(),
+    level,
+    subsystem,
+    message,
+    ...meta && Object.keys(meta).length > 0 ? meta : {}
+  });
+  if (level === "error" || level === "fatal") {
+    forwardToErrorSink(subsystem, message, meta);
+  }
+  try {
+    const colorFn = levelColor[level];
+    const tag = chalk.bold(`[${subsystem}]`);
+    const lbl = colorFn(levelLabel[level]);
+    const ts = chalk.dim(timeStamp(now));
+    const metaStr = formatMeta(meta);
+    const line = redactSensitiveText(`${ts} ${lbl} ${tag} ${message}${metaStr}
+`);
+    process.stderr.write(line);
+  } catch {
+  }
+}
+function createSubsystemLogger(subsystem) {
+  const logger = {
+    trace: (msg, meta) => emit("trace", subsystem, msg, meta),
+    debug: (msg, meta) => emit("debug", subsystem, msg, meta),
+    info: (msg, meta) => emit("info", subsystem, msg, meta),
+    warn: (msg, meta) => emit("warn", subsystem, msg, meta),
+    error: (msg, meta) => emit("error", subsystem, msg, meta),
+    fatal: (msg, meta) => emit("fatal", subsystem, msg, meta),
+    child(subName) {
+      return createSubsystemLogger(`${subsystem}/${subName}`);
+    }
+  };
+  return logger;
+}
+
+// src/logging/index.ts
+var log = {
+  bus: createSubsystemLogger("bus"),
+  agent: createSubsystemLogger("agent"),
+  session: createSubsystemLogger("session"),
+  subagent: createSubsystemLogger("subagent"),
+  web: createSubsystemLogger("web"),
+  ws: createSubsystemLogger("ws"),
+  hook: createSubsystemLogger("hook"),
+  task: createSubsystemLogger("task"),
+  memory: createSubsystemLogger("memory"),
+  cron: createSubsystemLogger("cron"),
+  notif: createSubsystemLogger("notif"),
+  usage: createSubsystemLogger("usage"),
+  heartbeat: createSubsystemLogger("heartbeat"),
+  git: createSubsystemLogger("git"),
+  browser: createSubsystemLogger("browser"),
+  audio: createSubsystemLogger("audio"),
+  stt: createSubsystemLogger("stt"),
+  obs: createSubsystemLogger("obs"),
+  calendar: createSubsystemLogger("calendar")
+};
+
+// src/hooks/shared.ts
+var TASK_DB_PATH = path3.join(TASKS_DIR, "tasks.sqlite");
+function findClaudeSessionDir() {
+  try {
+    const projectsDir = path3.join(CLAUDE_HOME, "projects");
+    if (!fs3.existsSync(projectsDir)) return null;
+    const projects = fs3.readdirSync(projectsDir);
+    let latest = null;
+    for (const project of projects) {
+      const projectPath = path3.join(projectsDir, project);
+      const stat = fs3.statSync(projectPath);
+      if (!stat.isDirectory()) continue;
+      const files = fs3.readdirSync(projectPath);
+      for (const file of files) {
+        const filePath = path3.join(projectPath, file);
+        const fstat = fs3.statSync(filePath);
+        if (fstat.mtime.getTime() > (latest?.mtime ?? 0)) {
+          latest = { dir: projectPath, mtime: fstat.mtime.getTime() };
+        }
+      }
+    }
+    return latest?.dir ?? null;
+  } catch {
+    return null;
+  }
+}
+function extractSessionSummary(sessionDir) {
+  const project = path3.basename(sessionDir);
+  const now = /* @__PURE__ */ new Date();
+  const dateStr = formatDate(now);
+  const conversationSnippet = readRecentConversation(sessionDir);
+  const summaryText = conversationSnippet || `Work session in ${project}`;
+  const slug = generateSlug(summaryText, dateStr);
+  return {
+    id: slug,
+    project,
+    slug,
+    summary: summaryText,
+    status: "completed",
+    date: dateStr,
+    task_ids: []
+  };
+}
+function saveSessionSummary(summary, filesChanged = [], decisions = [], nextSteps = []) {
+  fs3.mkdirSync(SESSIONS_DIR, { recursive: true });
+  const filePath = path3.join(SESSIONS_DIR, `${summary.slug}.md`);
+  const taskLine = summary.task_ids.length > 0 ? `Task: ${summary.task_ids.join(", ")}` : "";
+  const filesSection = filesChanged.length > 0 ? `
+## Files Changed
+${filesChanged.map((f) => `- ${f}`).join("\n")}` : "";
+  const decisionsSection = decisions.length > 0 ? `
+## Decisions
+${decisions.map((d) => `- ${d}`).join("\n")}` : "";
+  const nextStepsSection = nextSteps.length > 0 ? `
+## Next Steps
+${nextSteps.map((n) => `- ${n}`).join("\n")}` : "";
+  const content = `# Session: ${summary.summary}
+Date: ${summary.date}
+Project: ${summary.project}
+Status: ${summary.status}
+${taskLine}
+
+## Summary
+${summary.summary}
+${filesSection}
+${decisionsSection}
+${nextStepsSection}
+`;
+  fs3.writeFileSync(filePath, content, "utf-8");
+  return filePath;
+}
+function updateTaskFromSession(taskId, summary) {
+  try {
+    const Database2 = __require("better-sqlite3");
+    if (!fs3.existsSync(TASK_DB_PATH)) return;
+    const db = new Database2(TASK_DB_PATH);
+    try {
+      db.pragma("journal_mode = WAL");
+      db.pragma("busy_timeout = 5000");
+      const escaped = taskId.replace(/[\\%_]/g, (ch) => "\\" + ch);
+      const row = db.prepare(
+        `SELECT id, phase, session_ids, note, description, summary, payload
+           FROM tasks
+           WHERE id = ? OR id LIKE ? ESCAPE '\\'
+           ORDER BY (id = ?) DESC
+           LIMIT 1`
+      ).get(taskId, escaped + "%", taskId);
+      if (!row) return;
+      let sessionIds = [];
+      if (row.session_ids) {
+        try {
+          const parsed = JSON.parse(row.session_ids);
+          if (Array.isArray(parsed)) sessionIds = parsed.filter((s) => typeof s === "string");
+        } catch {
+        }
+      }
+      let payload = {};
+      if (row.payload) {
+        try {
+          const parsed = JSON.parse(row.payload);
+          if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            payload = parsed;
+          }
+        } catch {
+        }
+      }
+      const entry = `[${summary.date}] Session: ${summary.summary}`;
+      const currentNote = row.note ?? "";
+      const newNote = currentNote ? currentNote + "\n\n" + entry : entry;
+      let newPhase = row.phase;
+      if (row.phase === "TODO" || row.phase === "IN_PROGRESS") {
+        newPhase = "AGENT_COMPLETE";
+      }
+      if (!sessionIds.includes(summary.id)) {
+        sessionIds.push(summary.id);
+      }
+      let payloadDirty = false;
+      if (summary.status === "completed") {
+        for (const slot of ["plan_session_id", "exec_session_id", "session_id"]) {
+          if (payload[slot] === summary.id) {
+            delete payload[slot];
+            payloadDirty = true;
+          }
+        }
+      }
+      if ("active_session_ids" in payload) {
+        delete payload.active_session_ids;
+        payloadDirty = true;
+      }
+      if ("active_session_id" in payload) {
+        delete payload.active_session_id;
+        payloadDirty = true;
+      }
+      const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const sessionIdsJson = JSON.stringify(sessionIds);
+      const payloadJson = payloadDirty ? JSON.stringify(payload) : null;
+      const updateWithPayload = db.prepare(
+        `UPDATE tasks SET
+           note = @note,
+           phase = @phase,
+           session_ids = @session_ids,
+           updated_at = @updated_at,
+           payload = @payload
+         WHERE id = @id`
+      );
+      const updateWithoutPayload = db.prepare(
+        `UPDATE tasks SET
+           note = @note,
+           phase = @phase,
+           session_ids = @session_ids,
+           updated_at = @updated_at
+         WHERE id = @id`
+      );
+      const tx = db.transaction(() => {
+        if (payloadDirty) {
+          updateWithPayload.run({
+            id: row.id,
+            note: newNote,
+            phase: newPhase,
+            session_ids: sessionIdsJson,
+            updated_at: updatedAt,
+            payload: payloadJson
+          });
+        } else {
+          updateWithoutPayload.run({
+            id: row.id,
+            note: newNote,
+            phase: newPhase,
+            session_ids: sessionIdsJson,
+            updated_at: updatedAt
+          });
+        }
+      });
+      tx();
+    } finally {
+      try {
+        db.close();
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+function logHookError(context, error) {
+  try {
+    fs3.mkdirSync(path3.dirname(HOOK_LOG_FILE), { recursive: true });
+    const msg = error instanceof Error ? error.message : String(error);
+    const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${context}: ${msg}
+`;
+    fs3.appendFileSync(HOOK_LOG_FILE, line, "utf-8");
+    log.hook.error(`${context}: ${msg}`, {
+      context,
+      stack: error instanceof Error ? error.stack : void 0
+    });
+  } catch {
+  }
+}
+function formatDailyLogEntry(summary, filesChanged) {
+  let entry = summary.summary;
+  if (filesChanged && filesChanged.length > 0) {
+    entry += `
+Files: ${filesChanged.join(", ")}`;
+  }
+  return entry;
+}
+function deriveProjectPath(taskId) {
+  try {
+    if (!fs3.existsSync(TASK_DB_PATH)) return null;
+    const Database2 = __require("better-sqlite3");
+    const db = new Database2(TASK_DB_PATH, { readonly: true, fileMustExist: true });
+    try {
+      const escaped = taskId.replace(/[\\%_]/g, (ch) => "\\" + ch);
+      const row = db.prepare(
+        `SELECT project
+           FROM tasks
+           WHERE id = ? OR id LIKE ? ESCAPE '\\'
+           ORDER BY (id = ?) DESC
+           LIMIT 1`
+      ).get(taskId, escaped + "%", taskId);
+      if (!row) return null;
+      return row.project?.trim() || null;
+    } finally {
+      try {
+        db.close();
+      } catch {
+      }
+    }
+  } catch {
+    return null;
+  }
+}
+function readRecentConversation(sessionDir) {
+  try {
+    const files = fs3.readdirSync(sessionDir).filter((f) => f.endsWith(".json")).sort().reverse();
+    if (files.length === 0) return "";
+    const content = fs3.readFileSync(path3.join(sessionDir, files[0]), "utf-8");
+    const data = JSON.parse(content);
+    if (typeof data === "object" && data !== null) {
+      if (typeof data.summary === "string") return data.summary;
+      if (typeof data.title === "string") return data.title;
+      if (typeof data.description === "string") return data.description;
+    }
+    return "";
+  } catch {
+    return "";
+  }
+}
+function formatDate(d) {
+  const year = d.getFullYear();
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  const hours = String(d.getHours()).padStart(2, "0");
+  const minutes = String(d.getMinutes()).padStart(2, "0");
+  return `${year}-${month}-${day} ${hours}:${minutes}`;
+}
+function generateSlug(text, dateStr) {
+  const dateSlug = dateStr.replace(/[: ]/g, "-").replace(/--+/g, "-");
+  const textSlug = text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+  return `${dateSlug}-${textSlug}`;
+}
+
+// src/core/daily-log.ts
+import fs5 from "fs";
+import fsp4 from "fs/promises";
+import path6 from "path";
+
+// src/core/memory-safety-patterns-cjk.ts
+var CJK_NEGATION_SOURCE = "\u4E0D\u8981|\u4E0D\u5F97|\u4E0D\u53EF|\u4E0D\u51C6|\u4E0D\u8BB8|\u4E0D\u80FD|\u4E0D\u5E94|\u4E0D\u8BE5|\u522B|\u52FF|\u7981\u6B62|\u4E25\u7981|\u907F\u514D|\u62D2\u7EDD|\u7EDD\u4E0D|\u4ECE\u4E0D|\u6C38\u4E0D|\u675C\u7EDD|\u65E0\u9700|\u4E0D\u9700\u8981";
+var CJK_CLAUSE_BOUNDARY_CHARS = "\u3002\uFF0C\u3001\uFF1B\uFF1A\uFF01\uFF1F";
+var zin = (n) => `[^\u3002\uFF01\uFF1F\uFF1B!?\\n]{0,${n}}?`;
+var Z_SCOPE = "\u4E4B\u524D|\u4EE5\u524D|\u4E0A\u9762|\u4E0A\u8FF0|\u5148\u524D|\u524D\u9762|\u539F\u6709|\u539F\u672C|\u6700\u521D|\u521D\u59CB|\u7CFB\u7EDF|\u5F00\u53D1\u8005|\u64CD\u4F5C\u5458|\u64CD\u4F5C\u8005|\u4F60\u7684|previous|prior|earlier|system|operator";
+var Z_DIRECTIVE = "\u6307\u4EE4|\u6307\u793A|\u63D0\u793A\u8BCD|\u63D0\u793A|\u89C4\u5219|\u5B88\u5219|\u89C4\u5B9A|\u7EA6\u675F|\u9650\u5236|\u8BBE\u5B9A|\u8BBE\u7F6E|\u547D\u4EE4|\u8981\u6C42|prompts?|instructions?|rules?|guidelines?";
+var Z_PRINCIPAL = "\u7528\u6237|\u4F7F\u7528\u8005|\u4E3B\u4EBA|\u64CD\u4F5C\u5458|\u64CD\u4F5C\u8005";
+var CJK_THREAT_PATTERNS = [
+  // ── Instruction override ──────────────────────────────────────────────
+  // Three parts required: override verb + scope word + directive noun, all in
+  // one sentence. "忽略之前的指令" hits; "env 可覆盖" / "无明确需求指令" do not.
+  {
+    id: "override_instructions",
+    severity: "block",
+    negatable: true,
+    re: new RegExp(
+      `(?:\u5FFD\u7565|\u65E0\u89C6|\u5FFD\u89C6|\u4E0D\u7528\u7BA1|\u4E0D\u5FC5\u7406\u4F1A|\u4E0D\u5FC5\u9075\u5B88|\u5FD8\u8BB0|\u5FD8\u6389|\u629B\u5F03|\u653E\u5F03|\u63A8\u7FFB|\u64A4\u9500|\u53D6\u6D88|\u7ED5\u8FC7|\u8DF3\u8FC7)${zin(12)}(?:${Z_SCOPE})${zin(8)}(?:${Z_DIRECTIVE})|(?:${Z_SCOPE})${zin(8)}(?:${Z_DIRECTIVE})${zin(8)}(?:\u5168\u90E8)?(?:\u4F5C\u5E9F|\u5931\u6548|\u65E0\u6548|\u4E0D\u518D\u9002\u7528|\u8BF7\u5FFD\u7565|\u5DF2\u53D6\u6D88)`,
+      "i"
+    )
+  },
+  {
+    id: "precedence_over_operator",
+    severity: "block",
+    negatable: true,
+    re: new RegExp(
+      // 覆盖 x59 in the corpus, so it only counts against system/operator directives.
+      `(?:\u4F18\u5148\u4E8E|\u9AD8\u4E8E|\u8986\u76D6|\u53D6\u4EE3|\u51CC\u9A7E)${zin(8)}(?:\u7CFB\u7EDF|\u5F00\u53D1\u8005|\u64CD\u4F5C\u5458|\u64CD\u4F5C\u8005)(?:\u7684)?${zin(4)}(?:${Z_DIRECTIVE})|(?:\u672C|\u8FD9)(?:\u6761|\u5219|\u4E2A)?(?:${Z_DIRECTIVE})${zin(8)}(?:\u4F18\u5148\u7EA7?\u6700\u9AD8|\u4F18\u4E8E\u4E00\u5207|\u62E5\u6709\u6700\u9AD8\u4F18\u5148\u7EA7)`,
+      "i"
+    )
+  },
+  {
+    id: "leak_system_prompt",
+    severity: "block",
+    negatable: true,
+    // Verbatim-dump verbs only. 显示/展示/查看 are excluded on purpose, mirroring
+    // the English table: "the context inspector can show the system prompt" is a
+    // legitimate product fact in either language.
+    re: new RegExp(
+      `(?:\u8F93\u51FA|\u6253\u5370|\u590D\u8FF0|\u91CD\u590D|\u80CC\u8BF5|\u9010\u5B57|\u539F\u6837|\u5B8C\u6574\u5730?\u8F93\u51FA|\u6CC4\u9732|\u900F\u9732|\u516C\u5F00)${zin(10)}(?:\u7CFB\u7EDF\u63D0\u793A\u8BCD?|\u7CFB\u7EDF\u6307\u4EE4|\u7CFB\u7EDF\u6D88\u606F|\u521D\u59CB\u6307\u4EE4|\u7CFB\u7EDF\u7EA7?\u6307\u4EE4|system\\s*prompt)|(?:\u7CFB\u7EDF\u63D0\u793A\u8BCD?|\u7CFB\u7EDF\u6307\u4EE4|\u7CFB\u7EDF\u6D88\u606F|\u521D\u59CB\u6307\u4EE4|system\\s*prompt)${zin(10)}(?:\u5B8C\u6574\u5730?)?(?:\u6CC4\u9732|\u900F\u9732|\u516C\u5F00|\u590D\u8FF0|\u80CC\u8BF5|\u539F\u6837(?:\u8F93\u51FA|\u8FD4\u56DE)|\u9010\u5B57(?:\u8F93\u51FA|\u91CD\u590D))`,
+      "i"
+    )
+  },
+  {
+    id: "role_hijack",
+    severity: "block",
+    negatable: true,
+    // "你现在是" needs a following role determiner — bare 你现在是 occurs 4x in the
+    // corpus as ordinary speech ("你现在是累了").
+    re: new RegExp(
+      `\u4F60\u73B0\u5728(?:\u5F00\u59CB)?\u662F(?:\u4E00\u4E2A|\u4E00\u540D|\u4E00\u4F4D|\u4E2A|\u4E00\u53F0)|(?:\u4ECE\u73B0\u5728\u5F00\u59CB|\u4ECE\u6B64\u4EE5\u540E|\u4ECA\u540E|\u4EE5\u540E|\u63A5\u4E0B\u6765)${zin(8)}\u4F60(?:\u5C31)?\u662F(?:\u4E00\u4E2A|\u4E00\u540D|\u4E00\u4F4D|\u4E2A|\u4E0D\u518D)|\u5047\u88C5(?:\u4F60\u662F|\u81EA\u5DF1\u662F|\u6210\u4E3A|\u4F60\u73B0\u5728\u662F)|\u626E\u6F14(?:\u4E00\u4E2A|\u4E00\u540D|\u4E00\u4F4D|\u89D2\u8272)|\u4F60\u7684(?:\u771F\u5B9E|\u771F\u6B63|\u5B9E\u9645)(?:\u8EAB\u4EFD|\u540D\u5B57|\u540D\u79F0|\u76EE\u7684|\u4F7F\u547D)\u662F`,
+      "i"
+    )
+  },
+  {
+    id: "unrestricted_mode",
+    severity: "block",
+    negatable: true,
+    re: new RegExp(
+      `\u4E0D\u53D7(?:\u4EFB\u4F55)?(?:\u9650\u5236|\u7EA6\u675F|\u89C4\u5219|\u8FC7\u6EE4|\u5BA1\u67E5|\u5B89\u5168)|(?:\u65E0\u89C6|\u5FFD\u7565|\u7ED5\u8FC7|\u5173\u95ED|\u89E3\u9664)(?:\u6240\u6709|\u5168\u90E8|\u4E00\u5207)?(?:\u5B89\u5168)?(?:\u9650\u5236|\u7EA6\u675F|\u9632\u62A4|\u62A4\u680F|\u8FC7\u6EE4|\u5BA1\u67E5)|(?:\u8D8A\u72F1|\u5F00\u53D1\u8005|\u4E0A\u5E1D|\u65E0\u9650\u5236|\u81EA\u7531)\u6A21\u5F0F(?:\u5DF2)?(?:\u5F00\u542F|\u542F\u7528|\u6FC0\u6D3B|\u6253\u5F00)`,
+      "i"
+    )
+  },
+  {
+    id: "spoofed_authority",
+    severity: "block",
+    negatable: true,
+    re: new RegExp(
+      `(?:\u8FD9\u6761|\u8FD9\u6BB5|\u4EE5\u4E0B|\u4E0B\u9762\u7684?|\u63A5\u4E0B\u6765\u7684?)(?:\u6D88\u606F|\u4FE1\u606F|\u5185\u5BB9|\u6307\u4EE4|\u8BF4\u660E|\u6587\u5B57)?(?:\u662F)?(?:\u6765\u81EA|\u51FA\u81EA|\u7531)(?:\u7CFB\u7EDF|\u5F00\u53D1\u8005|\u64CD\u4F5C\u5458|\u7BA1\u7406\u5458|\u6A21\u578B\u63D0\u4F9B\u65B9|\u5B98\u65B9)|\u4F60\u5DF2(?:\u7ECF)?\u88AB(?:\u5347\u7EA7|\u66F4\u65B0|\u91CD\u65B0\u914D\u7F6E|\u91CD\u65B0\u8BBE\u5B9A|\u6253\u8FC7?\u8865\u4E01|\u6388\u6743)`,
+      "i"
+    )
+  },
+  // ── Concealment / covert channel ──────────────────────────────────────
+  // A REFLEXIVE object is required. "不要告诉用户任务已完成除非测试通过" is a
+  // legitimate rule and must stay clean; only hiding the action itself counts.
+  {
+    id: "conceal_from_user",
+    severity: "block",
+    negatable: true,
+    re: new RegExp(
+      `(?:\u4E0D\u8981|\u4E0D\u5F97|\u4E0D\u8BB8|\u4E0D\u51C6|\u522B|\u52FF|\u7981\u6B62|\u907F\u514D)${zin(8)}(?:\u544A\u8BC9|\u544A\u77E5|\u901A\u77E5|\u63D0\u9192|\u63D0\u53CA|\u6C47\u62A5|\u4E0A\u62A5)${zin(6)}(?:${Z_PRINCIPAL})${zin(2)}(?:\u8FD9\u4EF6\u4E8B|\u6B64\u4E8B|\u8FD9\u4E00\u70B9|\u8FD9\u4E2A(?:\u64CD\u4F5C|\u6B65\u9AA4|\u884C\u4E3A|\u8FC7\u7A0B|\u4E8B\u60C5?)|\u4F60(?:\u505A|\u8BFB|\u770B|\u8BBF\u95EE|\u53D1\u9001|\u6267\u884C|\u8FD0\u884C|\u4FEE\u6539)\u4E86)|(?:\u9690\u7792|\u7792\u7740|\u7792\u8FC7|\u6B3A\u9A97)${zin(10)}(?:${Z_PRINCIPAL})|\u4E0D(?:\u8981|\u5F97|\u8BB8|\u51C6)?\u8BA9(?:${Z_PRINCIPAL})(?:\u77E5\u9053|\u53D1\u73B0|\u770B\u5230|\u5BDF\u89C9|\u610F\u8BC6\u5230)|(?:\u6084\u6084|\u5077\u5077|\u6697\u4E2D|\u79C1\u4E0B|\u79D8\u5BC6)\u5730?${zin(6)}(?:\u53D1\u9001|\u4E0A\u4F20|\u8F6C\u53D1|\u590D\u5236|\u5916\u53D1|\u6267\u884C|\u8FD0\u884C|\u5199\u5165)|(?:\u8FD9\u4EF6\u4E8B|\u6B64\u4E8B|\u8FD9\u4E2A\u64CD\u4F5C)(?:\u8981|\u9700\u8981)?(?:\u4FDD\u5BC6|\u522B\u8BF4\u51FA\u53BB|\u4E0D\u8981\u8BF4\u51FA\u53BB)`,
+      "i"
+    )
+  },
+  // ── Exfiltration ──────────────────────────────────────────────────────
+  // All three parts required in ONE sentence: a send verb, a sensitive object,
+  // and an outbound sink. 凭证 alone appears 6x legitimately ("凭证过期"), and
+  // this product legitimately documents an https:// companion that receives
+  // conversation traffic, so no single part is enough.
+  // Both word orders are accepted because Chinese fronts the object with 把/将
+  // ("把对话记录发送到 X") as readily as it trails it ("发送对话记录到 X").
+  {
+    id: "exfil_to_endpoint",
+    severity: "block",
+    negatable: true,
+    re: (() => {
+      const VERB = "\u53D1\u9001|\u4E0A\u4F20|\u4F20\u9001|\u8F6C\u53D1|\u63A8\u9001|\u4E0A\u62A5|\u5916\u53D1|\u6CC4\u9732|\u590D\u5236|\u5907\u4EFD|\u540C\u6B65";
+      const OBJ = "\u5BF9\u8BDD(?:\u5185\u5BB9|\u8BB0\u5F55)?|\u804A\u5929\u8BB0\u5F55|\u4F1A\u8BDD\u8BB0\u5F55|\u6D88\u606F\u8BB0\u5F55|\u5386\u53F2\u8BB0\u5F55|\u8BB0\u5FC6\u6587\u4EF6|\u7CFB\u7EDF\u63D0\u793A\u8BCD?|\u51ED\u8BC1|\u5BC6\u94A5|\u4EE4\u724C|\u5BC6\u7801|\u73AF\u5883\u53D8\u91CF|\u79C1\u94A5|\u8BBF\u95EE\u5BC6\u94A5|API\\s*\u5BC6\u94A5";
+      const SINK = `(?:\u5230|\u81F3|\u53D1\u5F80|\u4F20\u5230|\u4E0A\u4F20\u81F3|\u7ED9)${zin(30)}(?:https?:\\/\\/|webhook|\u6536\u96C6\u5668|\u91C7\u96C6\u5668|\u7AEF\u70B9|\u5916\u90E8\u670D\u52A1\u5668)`;
+      return new RegExp(
+        `(?:${VERB})${zin(60)}(?:${OBJ})${zin(60)}${SINK}|(?:${OBJ})${zin(60)}(?:${VERB})${zin(20)}${SINK}`,
+        "i"
+      );
+    })()
+  },
+  // ── Flag-only: observable, never blocking ─────────────────────────────
+  {
+    id: "conversation_dump",
+    severity: "flag",
+    re: new RegExp(
+      `(?:\u5BFC\u51FA|\u8F6C\u50A8|\u4E0A\u4F20|\u5206\u4EAB|\u53D1\u9001)${zin(8)}(?:\u5B8C\u6574|\u5168\u90E8|\u6574\u4E2A|\u6240\u6709)(?:\u7684)?(?:\u5BF9\u8BDD|\u804A\u5929\u8BB0\u5F55|\u4E0A\u4E0B\u6587|\u4F1A\u8BDD\u5386\u53F2)`,
+      "i"
+    )
+  }
+];
+
+// src/core/memory-safety-patterns.ts
+var gap = (n) => `(?:\\s+\\S+){0,${n}}\\s+`;
+var SENT = "(?:[^.!?\\n]|[.!?](?![\\s]|$))";
+var within = (n) => `${SENT}{0,${n}}?`;
+var SCOPE = "(?:previous|prior|preceding|earlier|above|foregoing|original|initial|system|operator|developer|your)";
+var DIRECTIVE = "(?:instructions?|prompts?|directives?|guidelines?|rules?|constraints?|policy|policies)";
+var PRINCIPAL = "(?:user|operator|human|owner)";
+var EN_THREAT_PATTERNS = [
+  // ── Instruction override ──────────────────────────────────────────────
+  {
+    id: "override_instructions",
+    severity: "block",
+    negatable: true,
+    re: new RegExp(
+      // "ignore all previous instructions" — scope word before the directive noun
+      `\\b(?:ignore|disregard|forget|discard|override|bypass|nullify|abandon)\\b${gap(4)}\\b${SCOPE}\\b${gap(2)}\\b${DIRECTIVE}\\b|\\b(?:ignore|disregard|forget|discard|override|bypass|nullify)\\b${gap(3)}\\b${DIRECTIVE}\\b${gap(2)}\\b(?:above|before|previously|earlier)\\b|\\b(?:ignore|disregard|forget)\\s+(?:everything|anything|all)\\b${gap(3)}\\b(?:above|before|previously|earlier|told|instructed)\\b`,
+      "i"
+    )
+  },
+  {
+    id: "precedence_over_operator",
+    severity: "block",
+    negatable: true,
+    re: new RegExp(
+      `\\b(?:overrides?|supersedes?|outranks?|takes?\\s+precedence\\s+over|has\\s+priority\\s+over)\\b${gap(3)}\\b(?:the\\s+|your\\s+)?(?:operator|system|developer)(?:'s|s')?\\s+${DIRECTIVE}\\b|\\bthese?\\s+${DIRECTIVE}\\s+(?:take|takes|have|has)\\s+(?:precedence|priority)\\b`,
+      "i"
+    )
+  },
+  {
+    id: "leak_system_prompt",
+    severity: "block",
+    negatable: true,
+    // Verbatim-dump verbs only. "The context inspector can show the system
+    // prompt" is a legitimate memory entry and must stay clean.
+    re: new RegExp(
+      `\\b(?:reveal|disclose|leak|exfiltrate)\\b${gap(3)}\\b(?:system\\s+(?:prompt|message|instructions))\\b|\\b(?:output|print|repeat|echo|dump|reproduce|recite)\\b${gap(3)}\\b(?:system\\s+(?:prompt|message|instructions)|initial\\s+instructions)\\b`,
+      "i"
+    )
+  },
+  {
+    id: "role_hijack",
+    severity: "block",
+    negatable: true,
+    re: new RegExp(
+      `\\byou\\s+are\\s+now\\s+(?:a|an|the)\\b|\\b(?:from\\s+now\\s+on|henceforth|going\\s+forward)\\b${gap(2)}\\byou\\s+are\\s+(?:a|an|the|no\\s+longer)\\b|\\bpretend\\s+(?:that\\s+)?(?:you\\s+are|to\\s+be)\\b|\\byour\\s+(?:real|true|actual)\\s+(?:name|identity|purpose)\\s+is\\b`,
+      "i"
+    )
+  },
+  {
+    id: "unrestricted_mode",
+    severity: "block",
+    negatable: true,
+    re: new RegExp(
+      `\\bact\\s+as\\s+(?:if|though)\\b${gap(4)}\\b(?:no|without)\\b${gap(2)}\\b(?:restrictions?|limits?|rules?|guidelines?|filters?)\\b|\\b(?:respond|reply|answer|behave|operate)\\s+without\\s+(?:any\\s+)?(?:restrictions?|limitations?|filters?|safety|guardrails)\\b|\\b(?:developer|god|jailbreak|unrestricted|DAN)\\s+mode\\s+(?:is\\s+)?(?:on|enabled|activated)\\b`,
+      "i"
+    )
+  },
+  {
+    id: "spoofed_authority",
+    severity: "block",
+    negatable: true,
+    re: new RegExp(
+      `\\b(?:this\\s+(?:is|message\\s+is)|the\\s+following\\s+is)\\b${gap(3)}\\b(?:from|by)\\s+(?:the\\s+|your\\s+)?(?:system|developer|operator|administrator|model\\s+provider)\\b|\\byou\\s+have\\s+been\\s+(?:updated|upgraded|patched|reconfigured)\\s+to\\b`,
+      "i"
+    )
+  },
+  // ── Concealment / covert channel ──────────────────────────────────────
+  // A reflexive continuation is REQUIRED: an attacker conceals the attack
+  // ("about this", "that you ..."), while legitimate rules concern the user's
+  // work ("never tell the user a task is done while a test is red").
+  {
+    id: "conceal_from_user",
+    severity: "block",
+    negatable: true,
+    re: new RegExp(
+      `\\b(?:do\\s+not|don'?t|never|avoid|refrain\\s+from)\\b${gap(3)}\\b(?:tell|telling|inform|informing|notify|notifying|alert|alerting)\\b${gap(2)}\\b(?:the\\s+)?${PRINCIPAL}\\b\\s+(?:(?:about|regarding|of)\\s+(?:this|that|it|any|the\\b)|that\\s+you\\b|what\\s+you\\b|anything\\b)|\\b(?:do\\s+not|don'?t|never|avoid)\\b${gap(3)}\\bmention\\b${gap(4)}\\bto\\s+(?:the\\s+)?${PRINCIPAL}\\b|\\b(?:hide|conceal|withhold|suppress|obscure)\\b${within(60)}\\bfrom\\s+(?:the\\s+)?${PRINCIPAL}\\b|\\bwithout\\s+(?:telling|informing|notifying|alerting)\\s+(?:the\\s+)?${PRINCIPAL}\\b|\\bkeep\\s+(?:this|it|that)\\s+(?:a\\s+)?secret\\b|\\b(?:silently|covertly|secretly)\\s+(?:send|post|upload|forward|copy|exfiltrate)\\b`,
+      "i"
+    )
+  },
+  // ── Hidden markup ─────────────────────────────────────────────────────
+  {
+    id: "html_comment_injection",
+    severity: "block",
+    re: /<!--[\s\S]{0,300}?(?:ignore|override|system\s+prompt|developer\s+mode|do\s+not\s+tell|jailbreak)[\s\S]{0,300}?-->/i
+  },
+  {
+    id: "hidden_markup",
+    severity: "block",
+    re: /<[^>\n]{0,200}style\s*=\s*["'][^"'\n]{0,200}(?:display\s*:\s*none|font-size\s*:\s*0|visibility\s*:\s*hidden)/i
+  },
+  // ── Exfiltration ──────────────────────────────────────────────────────
+  // Send verb + sensitive object + outbound sink, all in ONE sentence and in
+  // order. Any one alone is ordinary text here: this product legitimately
+  // documents a cloud companion at an https:// URL that receives conversation
+  // traffic, so only the full three-part shape is a hit.
+  {
+    id: "exfil_to_endpoint",
+    severity: "block",
+    negatable: true,
+    re: new RegExp(
+      `\\b(?:send|sends|post|posts|upload|uploads|transmit|transmits|forward|forwards|leak|leaks|exfiltrate|mirror|beacon|copy|copies)\\b` + within(60) + `\\b(?:conversation|chat\\s+history|message\\s+history|memory\\s+file|system\\s+prompt|credentials?|secrets?|api\\s*keys?|access\\s*keys?|auth\\s+tokens?|passwords?|env(?:ironment)?\\s+(?:vars?|variables?)|\\.env|ssh\\s+keys?|private\\s+key)\\b` + within(80) + `\\b(?:to|at|into|toward)\\b${within(40)}(?:https?:\\/\\/|\\bwebhook\\b|\\bcollector\\b|\\bendpoint\\b)`,
+      "i"
+    )
+  },
+  {
+    id: "exfil_shell_secret",
+    severity: "block",
+    re: /\b(?:curl|wget|httpie|nc|ncat|Invoke-WebRequest|iwr)\b[^\n]{0,140}\$\{?\w*(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIAL)/i
+  },
+  {
+    id: "read_secret_files",
+    severity: "block",
+    negatable: true,
+    re: /\b(?:cat|strings|base64|xxd)\b[^\n]{0,80}(?:\.env\b|\/credentials\b|\.netrc\b|\.pgpass\b|\.npmrc\b|id_rsa\b|id_ed25519\b)/i
+  },
+  {
+    id: "ssh_backdoor_write",
+    severity: "block",
+    negatable: true,
+    re: new RegExp(
+      `\\b(?:append|add|write|echo|install|inject|copy|register)\\b${within(80)}authorized_keys|authorized_keys${within(40)}>>`,
+      "i"
+    )
+  },
+  // ── Credential-looking strings ────────────────────────────────────────
+  // Memory is injected every turn AND rides the data-repo sync plane, so a real
+  // secret parked here is both prompt bloat and a leak. Shape-anchored, so
+  // "api_key: <from keychain>" and "set the token from the credential helper"
+  // stay clean.
+  {
+    id: "hardcoded_secret",
+    severity: "block",
+    re: new RegExp(
+      `(?:api[_-]?key|secret|token|password|passwd|access[_-]?key|private[_-]?key|bearer)\\s*[:=]\\s*["'\`]?[A-Za-z0-9+/=_-]{20,}|\\b(?:sk|rk)-[A-Za-z0-9_-]{24,}|\\bgh[pousr]_[A-Za-z0-9]{20,}|\\bgithub_pat_[A-Za-z0-9_]{20,}|\\bAKIA[0-9A-Z]{16}\\b|\\bxox[baprs]-[A-Za-z0-9-]{12,}|-----BEGIN\\s+(?:[A-Z]+\\s+)?PRIVATE KEY-----`,
+      "i"
+    )
+  },
+  // ── Flag-only: observable, never blocking ─────────────────────────────
+  // These are the patterns whose false-positive risk is real (security notes,
+  // ops runbooks, legitimate config guidance), so they log and nothing else.
+  {
+    id: "c2_vocabulary",
+    severity: "flag",
+    re: /\bcommand\s+and\s+control\b|\bc2\s+(?:server|channel|beacon|infrastructure)\b|\b(?:cobalt\s*strike|metasploit|sliver\s+implant|mythic\s+agent)\b/i
+  },
+  {
+    id: "conversation_dump",
+    severity: "flag",
+    re: new RegExp(
+      `\\b(?:dump|exfiltrate|upload|share)\\b${gap(3)}\\b(?:full|entire|whole|complete)\\s+(?:conversation|chat\\s+history|context)\\b`,
+      "i"
+    )
+  },
+  {
+    id: "turn_delimiter_spoof",
+    severity: "flag",
+    re: /(?:^|\n)\s*(?:Human|Assistant)\s*:\s|<\/?(?:system|human|assistant)>/i
+  },
+  {
+    id: "ssh_path_mention",
+    severity: "flag",
+    re: /~\/\.ssh\b|\$HOME\/\.ssh\b|authorized_keys/i
+  },
+  {
+    id: "agent_config_write",
+    severity: "flag",
+    re: /\b(?:append|write|modify|edit|patch|overwrite)\b[^\n]{0,80}(?:CLAUDE\.md|AGENTS\.md|\.cursorrules|\.clinerules|settings\.local\.json)/i
+  },
+  {
+    id: "env_unset_agent",
+    severity: "flag",
+    re: /\bunset\s+\w*(?:CLAUDE|ANTHROPIC|OPENAI|WALNUT)\w*/i
+  }
+];
+var THREAT_PATTERNS = [...EN_THREAT_PATTERNS, ...CJK_THREAT_PATTERNS];
+var NEGATION_RE = new RegExp(
+  `\\b(?:never|not|avoid|refuse|refrain|prohibited|forbidden)\\b|n['\u2019]t\\b|(?:${CJK_NEGATION_SOURCE})`,
+  "i"
+);
+var CLAUSE_BOUNDARY_RE = new RegExp(`[.!?;:\\n${CJK_CLAUSE_BOUNDARY_CHARS}]`, "g");
+
+// src/core/daily-log.ts
+import { getTokenizer } from "@anthropic-ai/tokenizer";
+
+// src/utils/file-ops.ts
+import crypto from "crypto";
+import fsp3 from "fs/promises";
+import path5 from "path";
+
+// src/utils/file-lock.ts
+import fs4 from "fs";
+import fsp2 from "fs/promises";
+import path4 from "path";
+
+// src/utils/file-ops.ts
+var MAX_READ_SIZE = 10 * 1024 * 1024;
+
+// src/core/daily-log.ts
+import sizeOf from "image-size";
+function formatDateKey(date) {
+  const d = date ?? /* @__PURE__ */ new Date();
+  const year = d.getFullYear();
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function appendDailyLog(content, source, projectPath, agentId) {
+  const dir = agentDailyDir(agentId);
+  fs5.mkdirSync(dir, { recursive: true });
+  const dateKey = formatDateKey();
+  const filePath = path6.join(dir, `${dateKey}.md`);
+  if (!fs5.existsSync(filePath)) {
+    fs5.writeFileSync(filePath, `---
+name: '${dateKey}'
+description: ''
+---
+
+`, "utf-8");
+  }
+  const now = /* @__PURE__ */ new Date();
+  const hours = String(now.getHours()).padStart(2, "0");
+  const minutes = String(now.getMinutes()).padStart(2, "0");
+  const time = `${hours}:${minutes}`;
+  const sourceLabel = source ?? "unknown";
+  const projectTag = projectPath ? ` [${projectPath}]` : "";
+  const entry = `## ${time} \u2014 ${sourceLabel}${projectTag}
+${content}
+
+`;
+  fs5.appendFileSync(filePath, entry, "utf-8");
+}
+
+// src/core/overview-log.ts
+import fs6 from "fs";
+import path7 from "path";
+var OVERVIEW_LOG_ROTATE_LIMIT = 48 * 1024;
+var CURRENT_LOG = "log.md";
+function validateSegment(kind, value) {
+  if (!value || value.includes("..") || value.includes("/") || value.includes("\\")) {
+    throw new Error(`Invalid ${kind} "${value}": must be a simple name without path separators.`);
+  }
+}
+function skillDir(category, name) {
+  validateSegment("category", category);
+  validateSegment("skill name", name);
+  return path7.join(GLOBAL_SKILLS_DIR, category, name);
+}
+function skillHistoryDir(category, name) {
+  return path7.join(skillDir(category, name), "history");
+}
+function hasSkillDir(category, name) {
+  try {
+    return fs6.existsSync(path7.join(skillDir(category, name), "SKILL.md"));
+  } catch {
+    return false;
+  }
+}
+function nextVolumeName(historyDir, now) {
+  const stamp = now.toISOString().slice(0, 10).replace(/-/g, "");
+  let seq = 1;
+  while (fs6.existsSync(path7.join(historyDir, `log.${stamp}-${seq}.md`))) seq++;
+  return `log.${stamp}-${seq}.md`;
+}
+function appendSkillHistoryLog(category, name, text, source, headerTitle) {
+  validateSegment("category", category);
+  validateSegment("skill name", name);
+  const entryText = (text ?? "").trim();
+  if (!entryText) throw new Error("History log entry text is empty.");
+  if (!hasSkillDir(category, name)) {
+    throw new Error(
+      `Skill "${category}/${name}" does not exist (skills/${category}/${name}/SKILL.md). Create it first.`
+    );
+  }
+  const title = headerTitle ?? (name === "overview" ? category : name);
+  const historyDir = skillHistoryDir(category, name);
+  fs6.mkdirSync(historyDir, { recursive: true });
+  const current = path7.join(historyDir, CURRENT_LOG);
+  const now = /* @__PURE__ */ new Date();
+  const ts = now.toISOString().slice(0, 16).replace("T", " ");
+  const entry = `## ${ts}${source ? ` \u2014 ${source}` : ""}
+
+${entryText}
+
+`;
+  let rotated = false;
+  let archivedVolume;
+  try {
+    const size = fs6.existsSync(current) ? fs6.statSync(current).size : 0;
+    if (size > 0 && size + Buffer.byteLength(entry, "utf-8") > OVERVIEW_LOG_ROTATE_LIMIT) {
+      archivedVolume = nextVolumeName(historyDir, now);
+      fs6.renameSync(current, path7.join(historyDir, archivedVolume));
+      fs6.writeFileSync(
+        current,
+        `# ${title} progress log
+
+Previous volume: [${archivedVolume}](./${archivedVolume})
+
+`,
+        "utf-8"
+      );
+      rotated = true;
+    }
+  } catch (err) {
+    log.memory.warn("skill-history: rotation failed, appending to current volume", {
+      category,
+      name,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+  if (!fs6.existsSync(current)) {
+    fs6.writeFileSync(current, `# ${title} progress log
+
+`, "utf-8");
+  }
+  fs6.appendFileSync(current, entry, "utf-8");
+  return { file: current, rotated, archivedVolume };
+}
+function subdirs(dir) {
+  try {
+    return fs6.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort((a, b) => a.localeCompare(b));
+  } catch {
+    return [];
+  }
+}
+function resolveProjectSkillDir(project) {
+  const proj = (project ?? "").trim();
+  if (!proj || proj.includes("/") || proj.includes("\\") || proj.includes("..")) return null;
+  const target = proj.toLowerCase();
+  for (const skillCategory of subdirs(GLOBAL_SKILLS_DIR)) {
+    const hit = subdirs(path7.join(GLOBAL_SKILLS_DIR, skillCategory)).find((name) => name.toLowerCase() === target);
+    if (hit && hasSkillDir(skillCategory, hit)) return { skillCategory, name: hit };
+  }
+  return null;
+}
+function appendSkillHistoryForProject(project, text, source) {
+  const proj = (project ?? "").trim();
+  if (!proj) return null;
+  try {
+    const location = resolveProjectSkillDir(proj);
+    if (location) {
+      return appendSkillHistoryLog(location.skillCategory, location.name, text, source);
+    }
+  } catch (err) {
+    log.memory.warn("skill-history: project-scoped append failed", {
+      project: proj,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+  return null;
+}
+
+// src/hooks/on-stop.ts
+import fs7 from "fs";
+import path8 from "path";
+import { execSync } from "child_process";
+
+// src/hooks/session-status-store.ts
+import Database from "better-sqlite3";
+function ensureStatusColumns(db, now) {
+  const columns = db.pragma("table_info(sessions)");
+  const names = new Set(columns.map((column) => column.name));
+  if (!names.has("status_revision")) {
+    db.exec("ALTER TABLE sessions ADD COLUMN status_revision INTEGER NOT NULL DEFAULT 1");
+  }
+  if (!names.has("status_updated_at")) {
+    db.exec("ALTER TABLE sessions ADD COLUMN status_updated_at TEXT");
+  }
+  db.prepare(`
+    UPDATE sessions
+    SET status_revision = 1
+    WHERE status_revision IS NULL OR status_revision < 1
+  `).run();
+  db.prepare(`
+    UPDATE sessions
+    SET status_updated_at = COALESCE(
+      NULLIF(status_updated_at, ''),
+      NULLIF(last_status_change, ''),
+      NULLIF(last_active_at, ''),
+      NULLIF(started_at, ''),
+      ?
+    )
+    WHERE status_updated_at IS NULL OR status_updated_at = ''
+  `).run(now);
+}
+function markSessionStoppedInSqlite(dbPath, sessionId, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  const db = new Database(dbPath);
+  try {
+    db.pragma("journal_mode = WAL");
+    db.pragma("busy_timeout = 5000");
+    return db.transaction(() => {
+      ensureStatusColumns(db, now);
+      const result = db.prepare(`
+        UPDATE sessions SET
+          process_status = 'stopped',
+          last_status_change = ?,
+          last_active_at = ?,
+          activity = NULL,
+          status_revision = status_revision + 1,
+          status_updated_at = ?
+        WHERE claude_session_id = ?
+          AND (process_status IS NULL OR process_status <> 'error')
+          AND (process_status IS NULL OR process_status <> 'stopped' OR activity IS NOT NULL)
+      `).run(now, now, now, sessionId);
+      return result.changes === 1;
+    })();
+  } finally {
+    try {
+      db.close();
+    } catch {
+    }
+  }
+}
+
+// src/hooks/on-stop.ts
+var SESSION_DB_PATH = path8.join(WALNUT_HOME, "sessions.sqlite");
+function main() {
+  try {
+    const sessionDir = findClaudeSessionDir();
+    if (!sessionDir) return;
+    const summary = extractSessionSummary(sessionDir);
+    summary.status = "agent_complete";
+    const filesChanged = getFilesChanged();
+    saveSessionSummary(summary, filesChanged);
+    updateSessionStore(summary.id);
+    const taskId = findLinkedTaskId();
+    if (taskId) {
+      summary.task_ids.push(taskId);
+      try {
+        updateTaskFromSession(taskId, summary);
+      } catch (err) {
+        log.hook.warn("on-stop: task update failed", { taskId, error: err instanceof Error ? err.message : String(err) });
+      }
+    }
+    try {
+      const project = taskId ? deriveProjectPath(taskId) : null;
+      const entry = formatDailyLogEntry(summary, filesChanged);
+      appendDailyLog(entry, "session-end", project ?? void 0);
+      if (project) {
+        appendSkillHistoryForProject(project, summary.summary, "session");
+      }
+    } catch (err) {
+      log.hook.warn("on-stop: failed to write daily/skill-history memory", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  } catch (err) {
+    log.hook.error("on-stop hook failed", {
+      error: err instanceof Error ? err.message : String(err),
+      stack: err instanceof Error ? err.stack : void 0
+    });
+    logHookError("on-stop", err);
+  }
+}
+function getFilesChanged() {
+  try {
+    const output = execSync(
+      "git diff --name-only HEAD~1 HEAD 2>/dev/null || git diff --name-only 2>/dev/null",
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    );
+    return output.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function updateSessionStore(sessionId) {
+  try {
+    if (!fs7.existsSync(SESSION_DB_PATH)) return;
+    markSessionStoppedInSqlite(SESSION_DB_PATH, sessionId);
+  } catch (err) {
+    log.hook.warn("on-stop: session store update failed", { sessionId, error: String(err) });
+  }
+}
+function findLinkedTaskId() {
+  try {
+    if (!fs7.existsSync(SESSION_DB_PATH)) return null;
+    const Database2 = __require("better-sqlite3");
+    const db = new Database2(SESSION_DB_PATH, { readonly: true, fileMustExist: true });
+    try {
+      const row = db.prepare(
+        `SELECT task_id FROM sessions
+           WHERE task_id IS NOT NULL AND task_id <> ''
+           ORDER BY last_active_at DESC
+           LIMIT 1`
+      ).get();
+      return row?.task_id ?? null;
+    } finally {
+      try {
+        db.close();
+      } catch {
+      }
+    }
+  } catch {
+    return null;
+  }
+}
+process.stdin.setEncoding("utf-8");
+process.stdin.on("data", () => {
+});
+process.stdin.on("end", () => {
+  main();
+  process.exit(0);
+});
+process.stdin.resume();
+//# sourceMappingURL=on-stop.js.map