@albireo3754/agentlog 0.1.0

package/src/hook.ts

@@ -0,0 +1,74 @@
+/**
+ * AgentLog hook entry point.
+ *
+ * Invoked by Claude Code UserPromptSubmit hook via stdin JSON.
+ * Reads prompt, determines Daily Note path, delegates to note-writer.
+ *
+ * Design: fail silently — never interrupt Claude Code.
+ */
+
+import { loadConfig } from "./config.js";
+import { parseHookInput } from "./schema/hook-input.js";
+import { cwdToProject } from "./schema/daily-note.js";
+import { prettyPrompt } from "./schema/pretty-prompt.js";
+import { appendEntry } from "./note-writer.js";
+
+/** Read all stdin as a string. Works with both Bun and Node.js. */
+function readStdin(): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    process.stdin.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+    process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+    process.stdin.on("error", reject);
+  });
+}
+
+async function main(): Promise<void> {
+  // 1. Load config — if absent, hint and exit (not initialized)
+  const config = loadConfig();
+  if (!config) {
+    process.stderr.write("[agentlog] not initialized. Run: agentlog init ~/path/to/vault\n");
+    return;
+  }
+
+  // 2. Read stdin (cross-runtime: works with both Bun and Node.js)
+  const raw = await readStdin();
+
+  // 3. Parse hook input
+  let parsed;
+  try {
+    parsed = parseHookInput(raw);
+  } catch (err) {
+    process.stderr.write(`[agentlog] parse error: ${err}\n`);
+    return;
+  }
+
+  // 4. Build time string
+  const now = new Date();
+  const hh = String(now.getHours()).padStart(2, "0");
+  const mm = String(now.getMinutes()).padStart(2, "0");
+  const time = `${hh}:${mm}`;
+
+  // 5. Sanitize prompt — skip system noise
+  const prompt = prettyPrompt(parsed.prompt);
+  if (!prompt) return;
+
+  // 6. Append entry to Daily Note
+  const entry = {
+    time,
+    prompt,
+    sessionId: parsed.sessionId,
+    project: cwdToProject(parsed.cwd),
+    cwd: parsed.cwd,
+  };
+
+  try {
+    appendEntry(config, entry, now);
+  } catch (err) {
+    process.stderr.write(`[agentlog] write error: ${err}\n`);
+  }
+}
+
+main().catch((err) => {
+  process.stderr.write(`[agentlog] fatal: ${err}\n`);
+});

package/src/note-writer.ts

@@ -0,0 +1,255 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join, dirname } from "path";
+import type { AgentLogConfig, LogEntry, WriteResult } from "./types.js";
+import {
+  dailyNoteFileName,
+  buildAgentLogEntry,
+  buildSessionDivider,
+  buildLatestLine,
+  buildProjectHeader,
+  buildProjectMetadata,
+} from "./schema/daily-note.js";
+
+/** Zero-pads a number to 2 digits. */
+function pad2(n: number): string {
+  return String(n).padStart(2, "0");
+}
+
+/** Returns daily note file path for a given date. */
+export function dailyNotePath(config: AgentLogConfig, date: Date): string {
+  if (config.plain) {
+    const yyyy = date.getFullYear();
+    const mm = pad2(date.getMonth() + 1);
+    const dd = pad2(date.getDate());
+    return join(config.vault, `${yyyy}-${mm}-${dd}.md`);
+  }
+  return join(config.vault, "Daily", dailyNoteFileName(date));
+}
+
+/**
+ * Appends a log entry to the Daily Note.
+ *
+ * For plain mode: simple append (unchanged behavior).
+ * For normal mode: session-grouped ## AgentLog section.
+ *   - Groups entries by project (derived from cwd).
+ *   - Inserts session divider when session_id changes within a project.
+ *   - Keeps a pinned "> 🕐" latest-entry line at the top of ## AgentLog.
+ */
+export function appendEntry(
+  config: AgentLogConfig,
+  entry: LogEntry,
+  date: Date = new Date()
+): WriteResult {
+  const filePath = dailyNotePath(config, date);
+
+  if (config.plain) {
+    return appendPlain(filePath, entry, date);
+  }
+
+  const created = !existsSync(filePath);
+  if (created) {
+    mkdirSync(dirname(filePath), { recursive: true });
+  }
+
+  const content = created ? "" : readFileSync(filePath, "utf-8");
+  const newContent = insertIntoAgentLogSection(content, entry);
+  writeFileSync(filePath, newContent, "utf-8");
+  return { filePath, created, section: "agentlog" };
+}
+
+/**
+ * Insert entry into ## AgentLog section with session-grouped subsections.
+ *
+ * Output structure:
+ *   ## AgentLog
+ *   > 🕐 HH:MM — project › prompt        ← latest entry (always updated)
+ *
+ *   #### project · HH:MM <!-- cwd ses --> ← one section per cwd
+ *   - HH:MM entry
+ *   - - - - (ses_XXXXXXXX)               ← divider when session changes
+ *   - HH:MM entry
+ */
+function insertIntoAgentLogSection(content: string, entry: LogEntry): string {
+  const sessionShort = entry.sessionId.slice(0, 8);
+  const entryLine = buildAgentLogEntry(entry.time, entry.prompt);
+  const latestLine = buildLatestLine(entry.time, entry.project, entry.prompt);
+
+  const lines = content.split("\n");
+
+  // 1. Find or create ## AgentLog
+  let agentLogIdx = lines.findIndex((l) => l === "## AgentLog");
+  if (agentLogIdx === -1) {
+    if (lines.length > 0 && lines[lines.length - 1] !== "") {
+      lines.push("");
+    }
+    lines.push("## AgentLog");
+    agentLogIdx = lines.length - 1;
+  }
+
+  // Find end of ## AgentLog section (next ## heading or EOF)
+  let agentLogEnd = lines.length;
+  for (let i = agentLogIdx + 1; i < lines.length; i++) {
+    if (/^## [^#]/.test(lines[i])) {
+      agentLogEnd = i;
+      break;
+    }
+  }
+
+  // 2. Find > 🕐 latest line (first non-blank line after ## AgentLog)
+  let latestLineIdx = -1;
+  for (let i = agentLogIdx + 1; i < agentLogEnd; i++) {
+    if (lines[i] === "") continue;
+    if (lines[i].startsWith("> 🕐")) {
+      latestLineIdx = i;
+    }
+    break; // only check the first non-blank line
+  }
+
+  // 3. Find #### project subsection matching entry.cwd
+  // New format:    "#### HH:MM · project" + next line "<!-- cwd=<path> -->"
+  // Legacy meta:   "#### HH:MM · project" + next line "<!-- cwd=<path> ses=<short> -->"
+  // Legacy inline: "#### project · HH:MM <!-- cwd=<path> ses=<short> -->"
+  const metaRe = /^<!-- cwd=(.+?) -->$/;
+  const legacyMetaRe = /^<!-- cwd=(.+?) ses=([\w-]+) -->$/;
+  const legacyHeaderRe = /^#### .+ <!-- cwd=(.+?) ses=([\w-]+) -->$/;
+  // Match both new [[ses_...]] and legacy (ses_...) formats for backward compat
+  const dividerRe = /^- - - - (?:\[\[ses_([\w-]+)\]\]|\(ses_([\w-]+)\))$/;
+
+  let projectIdx = -1;
+  let projectMetaIdx = -1; // -1 means legacy inline format (no separate metadata line)
+  let legacySes = ""; // ses from legacy metadata, used as fallback when no dividers exist
+  let existingTime = entry.time;
+
+  for (let i = agentLogIdx + 1; i < agentLogEnd; i++) {
+    if (!lines[i].startsWith("#### ")) continue;
+
+    // Try new format: metadata on next line (no ses)
+    const meta = lines[i + 1]?.match(metaRe);
+    if (meta) {
+      const [, storedCwd] = meta;
+      if (storedCwd !== entry.cwd) continue;
+      projectIdx = i;
+      projectMetaIdx = i + 1;
+      const timeMatch = lines[i].match(/^#### (\d{2}:\d{2}) /);
+      if (timeMatch) existingTime = timeMatch[1];
+      break;
+    }
+
+    // Try legacy format: metadata with ses on next line
+    const legacyMeta = lines[i + 1]?.match(legacyMetaRe);
+    if (legacyMeta) {
+      const [, storedCwd, commentSes] = legacyMeta;
+      if (storedCwd !== entry.cwd) continue;
+      projectIdx = i;
+      projectMetaIdx = i + 1;
+      legacySes = commentSes;
+      const timeMatch = lines[i].match(/^#### (\d{2}:\d{2}) /);
+      if (timeMatch) existingTime = timeMatch[1];
+      break;
+    }
+
+    // Try legacy inline format
+    const legacy = lines[i].match(legacyHeaderRe);
+    if (legacy) {
+      const [, storedCwd, commentSes] = legacy;
+      if (storedCwd !== entry.cwd) continue;
+      projectIdx = i;
+      projectMetaIdx = -1;
+      legacySes = commentSes;
+      const timeMatch = lines[i].match(/· (\d{2}:\d{2}) /);
+      if (timeMatch) existingTime = timeMatch[1];
+      break;
+    }
+  }
+
+  // 4. Insert entry
+  if (projectIdx === -1) {
+    // New project: create #### section with initial session divider at end of ## AgentLog.
+    // The initial divider anchors the starting session so subsequent entries can compare.
+    const header = buildProjectHeader(entry.project, entry.time);
+    const meta = buildProjectMetadata(entry.cwd);
+    const prevLine = lines[agentLogEnd - 1];
+    const newSection: string[] = [];
+    if (prevLine !== "" && prevLine !== "## AgentLog") {
+      newSection.push("");
+    }
+    newSection.push(header, meta, buildSessionDivider(entry.sessionId), entryLine);
+    lines.splice(agentLogEnd, 0, ...newSection);
+  } else {
+    // Existing project: find end of this subsection
+    let subsectionEnd = agentLogEnd;
+    for (let i = projectIdx + 1; i < agentLogEnd; i++) {
+      if (lines[i].startsWith("#### ")) {
+        subsectionEnd = i;
+        break;
+      }
+    }
+
+    const firstContentIdx = projectMetaIdx === -1 ? projectIdx + 1 : projectMetaIdx + 1;
+    let insertAt = subsectionEnd;
+    while (insertAt > firstContentIdx && lines[insertAt - 1] === "") {
+      insertAt--;
+    }
+
+    // Determine current session from the last divider in this subsection.
+    // Falls back to legacySes (from old metadata format) if no dividers found.
+    let currentSes = "";
+    for (let i = firstContentIdx; i < subsectionEnd; i++) {
+      const m = lines[i].match(dividerRe);
+      if (m) currentSes = m[1] ?? m[2]; // group 1: new [[ses_...]], group 2: legacy (ses_...)
+    }
+    if (!currentSes) currentSes = legacySes;
+
+    if (currentSes !== sessionShort) {
+      // Session changed: insert divider + entry.
+      lines.splice(insertAt, 0, buildSessionDivider(entry.sessionId), entryLine);
+      // Migrate legacy metadata format to new format (remove ses=).
+      if (projectMetaIdx !== -1 && lines[projectMetaIdx].match(legacyMetaRe)) {
+        lines[projectMetaIdx] = buildProjectMetadata(entry.cwd);
+      } else if (projectMetaIdx === -1) {
+        // Legacy inline header → migrate to split format
+        lines[projectIdx] = buildProjectHeader(entry.project, existingTime);
+        lines.splice(projectIdx + 1, 0, buildProjectMetadata(entry.cwd));
+      }
+    } else {
+      lines.splice(insertAt, 0, entryLine);
+    }
+  }
+
+  // 5. Update > 🕐 latest line
+  // Note: latestLineIdx is always before insertAt, so it's unaffected by the splice above.
+  if (latestLineIdx !== -1) {
+    lines[latestLineIdx] = latestLine;
+  } else {
+    // Insert after ## AgentLog
+    if (lines[agentLogIdx + 1] === "") {
+      lines.splice(agentLogIdx + 1, 0, latestLine);
+    } else {
+      lines.splice(agentLogIdx + 1, 0, latestLine, "");
+    }
+  }
+
+  return lines.join("\n");
+}
+
+/** Plain mode: simple append without session grouping. */
+function appendPlain(filePath: string, entry: LogEntry, date: Date): WriteResult {
+  const created = !existsSync(filePath);
+
+  if (created) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    const yyyy = date.getFullYear();
+    const mm = pad2(date.getMonth() + 1);
+    const dd = pad2(date.getDate());
+    const header = `# ${yyyy}-${mm}-${dd}\n`;
+    writeFileSync(filePath, `${header}- ${entry.time} ${entry.prompt}\n`, "utf-8");
+    return { filePath, created: true, section: "plain" };
+  }
+
+  const content = readFileSync(filePath, "utf-8");
+  const appended = content.endsWith("\n")
+    ? content + `- ${entry.time} ${entry.prompt}\n`
+    : content + `\n- ${entry.time} ${entry.prompt}\n`;
+  writeFileSync(filePath, appended, "utf-8");
+  return { filePath, created: false, section: "plain" };
+}

package/src/obsidian-cli.ts

@@ -0,0 +1,86 @@
+/**
+ * Obsidian CLI (1.12+) detection and execution.
+ * Encapsulates all Obsidian CLI interaction so other modules
+ * only need to call these functions.
+ */
+
+import { spawnSync } from "child_process";
+import { existsSync } from "fs";
+
+/** Known macOS paths where Obsidian CLI binary may live (PATH may not include these). */
+const MACOS_CLI_PATHS = [
+  "/Applications/Obsidian.app/Contents/MacOS/obsidian",
+];
+
+type CliBinCacheState =
+  | { status: "unresolved" }
+  | { status: "resolved"; bin: string }
+  | { status: "not-found" };
+
+/** Cached CLI resolution state for PATH/macos fallback lookup. */
+let _cachedBinState: CliBinCacheState = { status: "unresolved" };
+
+function envOverrideBin(): string | null {
+  const raw = process.env.OBSIDIAN_BIN?.trim();
+  return raw ? raw : null;
+}
+
+/**
+ * Resolve the `obsidian` CLI binary path.
+ * Resolution order:
+ * 1) OBSIDIAN_BIN env override
+ * 2) `which obsidian`
+ * 3) known macOS app bundle paths
+ */
+export function resolveCliBin(): string | null {
+  const override = envOverrideBin();
+  if (override) return override;
+
+  if (_cachedBinState.status === "resolved") return _cachedBinState.bin;
+  if (_cachedBinState.status === "not-found") return null;
+
+  const which = spawnSync("which", ["obsidian"], { encoding: "utf-8", timeout: 3000 });
+  if (which.status === 0 && which.stdout.trim()) {
+    _cachedBinState = { status: "resolved", bin: which.stdout.trim() };
+    return _cachedBinState.bin;
+  }
+
+  if (process.platform === "darwin") {
+    for (const p of MACOS_CLI_PATHS) {
+      if (existsSync(p)) {
+        _cachedBinState = { status: "resolved", bin: p };
+        return _cachedBinState.bin;
+      }
+    }
+  }
+
+  _cachedBinState = { status: "not-found" };
+  return null;
+}
+
+/** Minimum Obsidian version that supports CLI */
+export const MIN_CLI_VERSION = "1.12.4";
+
+/** Extract version string from CLI stdout (last non-empty line). */
+export function parseCliVersion(stdout: string): string | null {
+  const lines = stdout.trim().split("\n").filter(Boolean);
+  return (lines.at(-1) ?? "").trim() || null;
+}
+
+/**
+ * Compare two semver-like version strings (e.g. "1.12.4" >= "1.12.4").
+ * Returns true if `version` >= `minimum`.
+ */
+export function isVersionAtLeast(version: string, minimum: string): boolean {
+  const parse = (v: string) => v.split(".").map((n) => parseInt(n, 10) || 0);
+  const ver = parse(version);
+  const min = parse(minimum);
+  for (let i = 0; i < Math.max(ver.length, min.length); i++) {
+    const a = ver[i] ?? 0;
+    const b = min[i] ?? 0;
+    if (a > b) return true;
+    if (a < b) return false;
+  }
+  return true; // equal
+}
+

package/src/schema/daily-note.ts

@@ -0,0 +1,84 @@
+/**
+ * Daily Note Schema — Time block detection patterns
+ *
+ * Defines the Korean Obsidian Daily Note time-block format that agentlog
+ * appends log entries into.
+ */
+
+/** Korean day names indexed by JS getDay() (0=Sunday) */
+export const KO_DAYS = ["일", "월", "화", "수", "목", "금", "토"] as const;
+
+/**
+ * Returns the Daily Note file name for a given date.
+ * Format: YYYY-MM-DD-요일.md  (e.g. 2026-03-01-일.md)
+ */
+export function dailyNoteFileName(date: Date): string {
+  const yyyy = date.getFullYear();
+  const mm = String(date.getMonth() + 1).padStart(2, "0");
+  const dd = String(date.getDate()).padStart(2, "0");
+  const day = KO_DAYS[date.getDay()];
+  return `${yyyy}-${mm}-${dd}-${day}.md`;
+}
+
+/**
+ * Derives project display name from cwd.
+ * Always returns "parent/basename" (2-level, no special cases).
+ * E.g. "/Users/pray/work/js/agentlog" → "js/agentlog"
+ *      "/Users/pray/worktrees/v5/gate" → "v5/gate"
+ */
+export function cwdToProject(cwd: string): string {
+  const parts = cwd.replace(/\/$/, "").split("/").filter(Boolean);
+  if (parts.length >= 2) {
+    return `${parts[parts.length - 2]}/${parts[parts.length - 1]}`;
+  }
+  return parts[parts.length - 1] ?? cwd;
+}
+
+/**
+ * Entry line within a #### project section.
+ * Format: "- HH:MM prompt"
+ */
+export function buildAgentLogEntry(time: string, prompt: string): string {
+  return `- ${time} ${prompt}`;
+}
+
+/**
+ * Session divider line inserted when session_id changes within a project section.
+ * Uses Obsidian wiki-link format so the session ID becomes a navigable link.
+ * Format: "- - - - [[ses_XXXXXXXX]]"
+ */
+export function buildSessionDivider(sessionId: string): string {
+  return `- - - - [[ses_${sessionId.slice(0, 8)}]]`;
+}
+
+/**
+ * Latest entry blockquote pinned at top of ## AgentLog section.
+ * Format: "> 🕐 HH:MM — project › prompt"
+ */
+export function buildLatestLine(time: string, project: string, prompt: string): string {
+  return `> 🕐 ${time} — ${project} › ${prompt}`;
+}
+
+/**
+ * Project subsection header line.
+ * Format: "#### HH:MM · project"
+ */
+export function buildProjectHeader(
+  project: string,
+  time: string,
+): string {
+  return `#### ${time} · ${project}`;
+}
+
+/**
+ * Metadata comment line placed directly below the project header.
+ * Stores cwd (matching key) for section identification.
+ * Format: "<!-- cwd=<path> -->"
+ *
+ * Kept on a separate line so the #### heading remains visually clean.
+ * HTML comments are hidden in Obsidian reading view.
+ * Session tracking is done via - - - - (ses_XXXXXXXX) divider lines in content.
+ */
+export function buildProjectMetadata(cwd: string): string {
+  return `<!-- cwd=${cwd} -->`;
+}

package/src/schema/hook-input.ts

@@ -0,0 +1,108 @@
+/**
+ * Hook Input Schema — Source of Truth
+ *
+ * Claude Code sends this JSON payload via stdin when a UserPromptSubmit hook fires.
+ * All fields are validated at runtime by parseHookInput().
+ */
+
+/** A single content part in the message */
+export interface HookInputPart {
+  type: "text";
+  text: string;
+}
+
+/** The message object nested inside hook input */
+export interface HookInputMessage {
+  content: string;
+}
+
+/**
+ * Full UserPromptSubmit hook payload from Claude Code.
+ *
+ * Required fields: hook_event_name, session_id, cwd
+ * Prompt is sourced from `prompt` (preferred) or `message.content` fallback.
+ */
+export interface HookInput {
+  hook_event_name: "UserPromptSubmit";
+  session_id: string;
+  cwd: string;
+  /** Path to the session transcript JSONL file */
+  transcript_path?: string;
+  /** Claude Code permission mode (e.g. "default", "acceptEdits") */
+  permission_mode?: string;
+  /** Direct prompt text — preferred source */
+  prompt?: string;
+  /** Nested message object — fallback if prompt is absent */
+  message?: HookInputMessage;
+  /** Structured content parts — secondary fallback */
+  parts?: HookInputPart[];
+}
+
+/** Parsed, normalized result after validating hook input */
+export interface ParsedHookInput {
+  sessionId: string;
+  cwd: string;
+  prompt: string;
+}
+
+/**
+ * Parse and validate raw hook stdin JSON.
+ *
+ * Prompt extraction priority:
+ *   1. input.prompt
+ *   2. input.message.content
+ *   3. input.parts[0].text (first text part)
+ *
+ * @throws {Error} if JSON is invalid or required fields are missing
+ */
+export function parseHookInput(raw: string): ParsedHookInput {
+  let input: unknown;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    throw new Error("Invalid JSON in hook stdin");
+  }
+
+  if (typeof input !== "object" || input === null) {
+    throw new Error("Hook input must be a JSON object");
+  }
+
+  const obj = input as Record<string, unknown>;
+
+  if (typeof obj["session_id"] !== "string" || !obj["session_id"]) {
+    throw new Error("Missing required field: session_id");
+  }
+  if (typeof obj["cwd"] !== "string" || !obj["cwd"]) {
+    throw new Error("Missing required field: cwd");
+  }
+
+  // Prompt extraction with fallback chain
+  let prompt: string | undefined;
+
+  if (typeof obj["prompt"] === "string" && obj["prompt"]) {
+    prompt = obj["prompt"];
+  } else if (
+    typeof obj["message"] === "object" &&
+    obj["message"] !== null &&
+    typeof (obj["message"] as Record<string, unknown>)["content"] === "string"
+  ) {
+    prompt = (obj["message"] as Record<string, unknown>)["content"] as string;
+  } else if (Array.isArray(obj["parts"])) {
+    const textPart = (obj["parts"] as HookInputPart[]).find(
+      (p) => p.type === "text" && typeof p.text === "string"
+    );
+    if (textPart) prompt = textPart.text;
+  }
+
+  if (!prompt) {
+    throw new Error(
+      "Cannot extract prompt: missing prompt, message.content, or parts[].text"
+    );
+  }
+
+  return {
+    sessionId: obj["session_id"] as string,
+    cwd: obj["cwd"] as string,
+    prompt,
+  };
+}

package/src/schema/pretty-prompt.ts

@@ -0,0 +1,91 @@
+/**
+ * prettyPrompt — Sanitize raw hook prompt for Daily Note display.
+ *
+ * Handles: framework injections (skip), multi-line collapsing,
+ * XML/HTML stripping, markdown flattening, and length truncation.
+ *
+ * Returns null when the prompt should not be logged (system noise).
+ */
+
+/** Prompts matching these are system/framework noise — skip entirely. */
+const SKIP_PATTERNS: RegExp[] = [
+  /^\[Request interrupted/,
+  /^<local-command-caveat>/,
+  /^<local-command-stdout>/,
+  /^<command-name>/,
+  /^<command-message>/,
+  /^<task-notification>/,
+  /^Base directory for this skill:/,
+  /^This session is being continued from a previous conversation/,
+  /^# \w.+ — /,
+  /^Stop hook feedback:/,
+  /^\[AUTOPILOT/,
+  /^\[RALPH LOOP/,
+  /^\[MAGIC KEYWORD/,
+];
+
+/**
+ * Collapse multi-line text into a summary.
+ * - 1-2 lines: join with space
+ * - 3+ lines: "first line (+N lines) last line"
+ * Empty lines after strip are excluded from count.
+ */
+function collapseLines(text: string): string {
+  const lines = text.split("\n").map((l) => l.replace(/\s{2,}/g, " ").trim()).filter(Boolean);
+  if (lines.length <= 2) {
+    return lines.join(" ");
+  }
+  const skipped = lines.length - 2;
+  return `${lines[0]} (+${skipped} lines) ${lines[lines.length - 1]}`;
+}
+
+/**
+ * Sanitize a raw prompt string for single-line Daily Note display.
+ * Returns null if the prompt is system noise and should not be logged.
+ */
+export function prettyPrompt(raw: string): string | null {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+
+  // 1. Skip system/framework injections
+  if (SKIP_PATTERNS.some((p) => p.test(trimmed))) return null;
+
+  // 2. Extract real prompt from AgentLog feedback block
+  //    e.g. "## AgentLog\n> 🕐 14:24 — project › actual prompt here"
+  const agentLogMatch = trimmed.match(
+    /^## AgentLog\n> [^\n]*?[›»]\s*(.+?)(?:\n|$)/m
+  );
+  if (agentLogMatch) return prettyPrompt(agentLogMatch[1]);
+
+  let text = trimmed;
+
+  // 3. Strip ANSI escape codes and control characters
+  text = text.replace(/\x1b\[[0-9;]*m/g, "");
+  text = text.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "");
+
+  // 4. Strip HTML/XML comments (<!-- ... -->)
+  text = text.replace(/<!--[\s\S]*?-->/g, "");
+
+  // 5. Strip wrapping XML tags (e.g. <system-reminder>...</system-reminder>)
+  text = text.replace(/<\/?[\w-]+>/g, "");
+
+  // 6. Strip markdown headings (##, ###, ####)
+  text = text.replace(/^#{1,6}\s+/gm, "");
+
+  // 7. Strip blockquote markers
+  text = text.replace(/^>\s*/gm, "");
+
+  // 8. Strip code fence markers
+  text = text.replace(/^```\w*$/gm, "");
+
+  // 9. Collapse multi-line: first line + (+N lines) + last line
+  text = collapseLines(text);
+
+  // 10. Trim again after all transformations
+  text = text.trim();
+
+  // 11. Too short after cleanup = noise
+  if (text.length < 2) return null;
+
+  return text;
+}