devrage 0.5.7 → 0.6.0

package/dist/cli.js

@@ -17,6 +17,7 @@ function ampAdapter() {
     name: "amp",
     async *messages(options) {
       const threadsDir = getAmpThreadsDir();
+      const role = options?.role ?? "user";
       let files;
       try {
         files = await readdir(threadsDir);
@@ -36,7 +37,7 @@ function ampAdapter() {
             continue;
           }
           for (const msg of thread.messages) {
-            if (msg.role !== "user") {
+            if (msg.role !== role) {
               continue;
             }
             const text = extractText(msg.content);
@@ -240,7 +241,11 @@ function claudeAdapter() {
     name: "claude",
     async *messages(options) {
       for await (const file of discoverClaudeJsonlFiles()) {
-        yield* parseClaudeJsonl(file.filePath, { ...file, since: options?.since });
+        yield* parseClaudeJsonl(file.filePath, {
+          ...file,
+          role: options?.role ?? "user",
+          since: options?.since
+        });
       }
     },
     async *usage(options) {
@@ -295,13 +300,14 @@ async function* parseClaudeJsonl(filePath, context) {
     input: createReadStream(filePath, { encoding: "utf-8" }),
     crlfDelay: Infinity
   });
+  const seenAssistantRows = /* @__PURE__ */ new Set();
   for await (const line of rl) {
     if (!line.trim()) {
       continue;
     }
     try {
       const entry = JSON.parse(line);
-      const text = extractUserText(entry);
+      const text = extractMessageText(entry, context.role);
       if (!text) {
         continue;
       }
@@ -312,6 +318,15 @@ async function* parseClaudeJsonl(filePath, context) {
           continue;
         }
       }
+      if (context.role === "assistant") {
+        const message = asRecord2(entry["message"]);
+        const messageId = stringValue(message?.["id"]) ?? stringValue(entry["uuid"]);
+        const dedupeKey = `${messageId ?? timestamp ?? ""}\0${text}`;
+        if (seenAssistantRows.has(dedupeKey)) {
+          continue;
+        }
+        seenAssistantRows.add(dedupeKey);
+      }
       yield {
         text,
         timestamp: timestamp ?? void 0,
@@ -322,22 +337,22 @@ async function* parseClaudeJsonl(filePath, context) {
     }
   }
 }
-function extractUserText(entry) {
-  if (entry["type"] === "user") {
-    const message = entry["message"];
+function extractMessageText(entry, role) {
+  if (entry["type"] === role) {
+    const message = asRecord2(entry["message"]);
     if (!message) {
       return null;
     }
     return contentToString(message["content"]);
   }
-  if (entry["type"] === "human") {
-    const message = entry["message"];
+  if (role === "user" && entry["type"] === "human") {
+    const message = asRecord2(entry["message"]);
     if (!message) {
       return null;
     }
     return contentToString(message["content"]);
   }
-  if (entry["role"] === "user") {
+  if (entry["role"] === role) {
     return contentToString(entry["content"]);
   }
   return null;
@@ -493,6 +508,7 @@ function clineAdapter() {
     name: "cline",
     async *messages(options) {
       const taskDirs = getClineTaskDirs();
+      const role = options?.role ?? "user";
       for (const tasksDir of taskDirs) {
         let taskIds;
         try {
@@ -514,7 +530,7 @@ function clineAdapter() {
               continue;
             }
             for (const msg of messages) {
-              if (msg.role !== "user") {
+              if (msg.role !== role) {
                 continue;
               }
               const text = extractText2(msg.content);
@@ -565,7 +581,11 @@ function codexAdapter() {
     name: "codex",
     async *messages(options) {
       for await (const file of discoverCodexSessionFiles(CODEX_SESSIONS_DIR)) {
-        yield* parseCodexJsonl(file.filePath, { session: file.session, since: options?.since });
+        yield* parseCodexJsonl(file.filePath, {
+          session: file.session,
+          role: options?.role ?? "user",
+          since: options?.since
+        });
       }
     },
     async *usage(options) {
@@ -623,18 +643,17 @@ async function* parseCodexJsonl(filePath, context) {
         continue;
       }
       const payload = entry.payload;
-      if (!payload || payload.role !== "user") {
+      if (!payload || payload.role !== context.role) {
         continue;
       }
-      const text = extractText3(payload.content);
+      const text = extractText3(payload.content, context.role);
       if (!text) {
         continue;
       }
-      if (text.startsWith("<environment_context>")) {
-        continue;
-      }
-      if (text.startsWith("<permissions instructions>")) {
-        continue;
+      if (context.role === "user") {
+        if (text.startsWith("<environment_context>") || text.startsWith("<permissions instructions>")) {
+          continue;
+        }
       }
       if (context.since && entry.timestamp) {
         const ts = new Date(entry.timestamp);
@@ -651,12 +670,13 @@ async function* parseCodexJsonl(filePath, context) {
     }
   }
 }
-function extractText3(content) {
+function extractText3(content, role) {
   if (!Array.isArray(content)) {
     return null;
   }
+  const textTypes = role === "assistant" ? /* @__PURE__ */ new Set(["output_text", "text"]) : /* @__PURE__ */ new Set(["input_text"]);
   const parts = content.filter(
-    (p) => typeof p === "object" && p !== null && p.type === "input_text" && typeof p.text === "string"
+    (p) => typeof p === "object" && p !== null && textTypes.has(p.type) && typeof p.text === "string"
   ).map((p) => p.text);
   return parts.length > 0 ? parts.join(" ") : null;
 }
@@ -670,6 +690,7 @@ async function* parseCodexUsageJsonl(filePath, context) {
   let previousUsageSignature = null;
   let session = context.session;
   let sawSessionMeta = false;
+  let forkReplayStartedAt = null;
   for await (const line of rl) {
     if (!line.trim()) {
       continue;
@@ -682,6 +703,15 @@ async function* parseCodexUsageJsonl(filePath, context) {
         if (metaSession && !sawSessionMeta) {
           session = metaSession;
           sawSessionMeta = true;
+          if (payload?.["thread_source"] === "subagent") {
+            forkReplayStartedAt = uuidV7Timestamp(metaSession) ?? timestampMilliseconds(entry["timestamp"]) ?? timestampMilliseconds(payload["timestamp"]);
+          }
+        }
+        continue;
+      }
+      if (forkReplayStartedAt !== null) {
+        if (isLiveForkTaskStart(entry, payload, forkReplayStartedAt)) {
+          forkReplayStartedAt = null;
         }
         continue;
       }
@@ -813,6 +843,35 @@ function numberValue2(value) {
 function stringValue2(value) {
   return typeof value === "string" && value.trim() ? value : void 0;
 }
+function isLiveForkTaskStart(entry, payload, forkStartedAt) {
+  if (entry["type"] !== "event_msg" || payload?.["type"] !== "task_started") {
+    return false;
+  }
+  const taskIdStartedAt = uuidV7Timestamp(stringValue2(payload["turn_id"]));
+  if (taskIdStartedAt !== null) {
+    return taskIdStartedAt >= forkStartedAt;
+  }
+  const taskStartedAt = timestampMilliseconds(payload["started_at"]);
+  return taskStartedAt !== null && taskStartedAt >= Math.floor(forkStartedAt / 1e3) * 1e3;
+}
+function uuidV7Timestamp(value) {
+  const normalized = value?.replaceAll("-", "");
+  if (!normalized || !/^[0-9a-f]{12}7/i.test(normalized)) {
+    return null;
+  }
+  const timestamp = Number.parseInt(normalized.slice(0, 12), 16);
+  return Number.isSafeInteger(timestamp) ? timestamp : null;
+}
+function timestampMilliseconds(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value >= 1e12 ? value : value * 1e3;
+  }
+  if (typeof value === "string") {
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) ? timestamp : null;
+  }
+  return null;
+}
 function asRecord3(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return null;
@@ -997,7 +1056,7 @@ async function* parseCursorStore(store, options) {
         if (parsed === void 0) {
           continue;
         }
-        for (const message of extractCursorMessages(parsed, row.key)) {
+        for (const message of extractCursorMessages(parsed, row.key, options?.role ?? "user")) {
           const text = message.text.trim();
           if (!isLikelyMessageText(text)) {
             continue;
@@ -1138,21 +1197,22 @@ function decodeStateValue(value) {
   }
   return null;
 }
-function extractCursorMessages(root, rowKey) {
+function extractCursorMessages(root, rowKey, role) {
   if (rowKey.startsWith("bubbleId:")) {
-    const message = extractCursorBubbleMessage(root, rowKey);
+    const message = extractCursorBubbleMessage(root, rowKey, role);
     return message ? [message] : [];
   }
   const messages = [];
-  collectRoleMessages(root, messages);
-  if (rowKey.startsWith("aiService.prompts") || rowKey.startsWith("aiService.generations")) {
+  collectRoleMessages(root, messages, role);
+  if (role === "user" && (rowKey.startsWith("aiService.prompts") || rowKey.startsWith("aiService.generations"))) {
     collectPromptMessages(root, messages);
   }
   return uniqueMessages(messages);
 }
-function extractCursorBubbleMessage(root, rowKey) {
+function extractCursorBubbleMessage(root, rowKey, role) {
   const record = asRecord4(root);
-  if (!record || numberValue3(record["type"]) !== 1) {
+  const expectedType = role === "user" ? 1 : 2;
+  if (!record || numberValue3(record["type"]) !== expectedType) {
     return null;
   }
   const text = firstTextField(record, ["text", "richText"]);
@@ -1248,13 +1308,13 @@ function cursorBubbleSession(rowKey) {
   const [, composerId] = rowKey.split(":");
   return composerId?.trim() || void 0;
 }
-function collectRoleMessages(value, messages, inheritedSession, depth = 0) {
+function collectRoleMessages(value, messages, role, inheritedSession, depth = 0) {
   if (depth > 12) {
     return;
   }
   if (Array.isArray(value)) {
     for (const item of value) {
-      collectRoleMessages(item, messages, inheritedSession, depth + 1);
+      collectRoleMessages(item, messages, role, inheritedSession, depth + 1);
     }
     return;
   }
@@ -1263,15 +1323,15 @@ function collectRoleMessages(value, messages, inheritedSession, depth = 0) {
     return;
   }
   const session = extractSession(record) ?? inheritedSession;
-  if (isUserAuthored(record)) {
-    const text = extractMessageText(record);
+  if (isAuthoredBy(record, role)) {
+    const text = extractMessageText2(record);
     if (text) {
       messages.push({ text, timestamp: extractTimestamp2(record), session });
     }
   }
   for (const child of Object.values(record)) {
     if (typeof child === "object" && child !== null) {
-      collectRoleMessages(child, messages, session, depth + 1);
+      collectRoleMessages(child, messages, role, session, depth + 1);
     }
   }
 }
@@ -1311,6 +1371,9 @@ function collectPromptMessages(value, messages, inheritedSession, depth = 0) {
     }
   }
 }
+function isAuthoredBy(record, role) {
+  return role === "user" ? isUserAuthored(record) : isAssistantAuthored(record);
+}
 function isUserAuthored(record) {
   return ["role", "speaker", "sender", "author", "source", "from", "type", "kind"].some(
     (field) => actorIsUser(record[field])
@@ -1344,7 +1407,7 @@ function actorString(value) {
   }
   return null;
 }
-function extractMessageText(record) {
+function extractMessageText2(record) {
   return firstTextField(record, ["text", "content", "message", "prompt", "query", "input"]);
 }
 function firstTextField(record, fields) {
@@ -1475,7 +1538,7 @@ function opencodeAdapter() {
         return;
       }
       try {
-        yield* queryUserMessages(db, options);
+        yield* queryMessages(db, options);
       } finally {
         db.close();
       }
@@ -1504,7 +1567,7 @@ async function openOpencodeDb() {
   }
   return db;
 }
-function* queryUserMessages(db, options) {
+function* queryMessages(db, options) {
   let query = `
     SELECT
       m.session_id,
@@ -1512,10 +1575,10 @@ function* queryUserMessages(db, options) {
       json_extract(p.data, '$.text') as text
     FROM message m
     JOIN part p ON p.message_id = m.id
-    WHERE json_extract(m.data, '$.role') = 'user'
+    WHERE json_extract(m.data, '$.role') = ?
       AND json_extract(p.data, '$.type') = 'text'
   `;
-  const params = [];
+  const params = [options?.role ?? "user"];
   if (options?.since) {
     query += ` AND m.time_created >= ?`;
     params.push(options.since.getTime());
@@ -1623,7 +1686,12 @@ async function* walkPiSessions(dir, options, project) {
       yield* walkPiSessions(fullPath, options, project ?? entry);
     } else if (entry.endsWith(".jsonl")) {
       const session = entry.replace(".jsonl", "");
-      yield* parsePiJsonl(fullPath, { session, project, since: options?.since });
+      yield* parsePiJsonl(fullPath, {
+        session,
+        project,
+        role: options?.role ?? "user",
+        since: options?.since
+      });
     }
   }
 }
@@ -1668,7 +1736,7 @@ async function* parsePiJsonl(filePath, context) {
         continue;
       }
       const message = entry.message;
-      if (!message || message.role !== "user") {
+      if (!message || message.role !== context.role) {
         continue;
       }
       const text = contentToString2(message.content);
@@ -1785,7 +1853,7 @@ function t3codeAdapter() {
           continue;
         }
         try {
-          yield* queryUserMessages2(db, location, options);
+          yield* queryMessages2(db, location, options);
         } finally {
           db.close();
         }
@@ -1847,7 +1915,7 @@ function resolveHomePath(value) {
 async function openT3Db(dbPath) {
   return openReadonlySqliteDatabase(dbPath);
 }
-function* queryUserMessages2(db, location, options) {
+function* queryMessages2(db, location, options) {
   if (!hasColumns(db, "projection_thread_messages", ["thread_id", "role", "text", "created_at"])) {
     return;
   }
@@ -1855,9 +1923,9 @@ function* queryUserMessages2(db, location, options) {
   let query = `
     SELECT thread_id, created_at, text
     FROM projection_thread_messages
-    WHERE role = 'user'
+    WHERE role = ?
   `;
-  const params = [];
+  const params = [options?.role ?? "user"];
   if (options?.since) {
     query += ` AND created_at >= ?`;
     params.push(options.since.toISOString());
@@ -2212,7 +2280,7 @@ function zedAdapter() {
     }
   };
 }
-async function* parseTextThreads(dir, _options) {
+async function* parseTextThreads(dir, options) {
   if (!existsSync5(dir)) {
     return;
   }
@@ -2232,8 +2300,9 @@ async function* parseTextThreads(dir, _options) {
       if (!conversation.messages || !Array.isArray(conversation.messages)) {
         continue;
       }
+      const role = options?.role ?? "user";
       for (const msg of conversation.messages) {
-        if (msg.role !== "user") {
+        if (msg.role !== role) {
           continue;
         }
         const text = typeof msg.content === "string" ? msg.content : null;
@@ -2249,7 +2318,7 @@ async function* parseTextThreads(dir, _options) {
     }
   }
 }
-async function* parseAgentThreads(dbDir, _options) {
+async function* parseAgentThreads(dbDir, options) {
   if (!existsSync5(dbDir)) {
     return;
   }
@@ -2285,8 +2354,8 @@ async function* parseAgentThreads(dbDir, _options) {
         continue;
       }
       const contentCol = colNames.includes("content") ? "content" : colNames.includes("body") ? "body" : "text";
-      let query = `SELECT "${contentCol}" as text FROM "${msgTable}" WHERE role = 'user'`;
-      const rows = db.prepare(query).all();
+      const query = `SELECT "${contentCol}" as text FROM "${msgTable}" WHERE role = ?`;
+      const rows = db.prepare(query).all(options?.role ?? "user");
       for (const row of rows) {
         if (!row.text?.trim()) {
           continue;
@@ -2921,6 +2990,281 @@ function asRecord7(value) {
   return value;
 }
 
+// src/slop/index.ts
+var SLOP_SIGNALS = [
+  // Claude's especially recognizable coding-agent voice.
+  {
+    tell: "load-bearing",
+    category: "claude-ism",
+    pattern: /\bload(?:[-‐‑‒–—\s]+)bearing\b/giu
+  },
+  {
+    tell: "honest take",
+    category: "claude-ism",
+    pattern: /\bhonest\s+(?:take|evaluation|assessment)\b/giu
+  },
+  {
+    tell: "precise mechanism",
+    category: "claude-ism",
+    pattern: /\b(?:the\s+)?precise\s+mechanism\b/giu
+  },
+  {
+    tell: "and that matters",
+    category: "claude-ism",
+    pattern: /\band\s+that\s+matters\b/giu
+  },
+  {
+    tell: "key insight",
+    category: "claude-ism",
+    pattern: /\b(?:the\s+)?key\s+insight\b/giu
+  },
+  {
+    tell: "without ceremony",
+    category: "claude-ism",
+    pattern: /\b(?:without|with\s+no|needs?\s+no|requires?\s+no|no)\s+(?:additional\s+)?ceremony\b/giu
+  },
+  {
+    tell: "earns its keep",
+    category: "claude-ism",
+    pattern: /\bearn(?:s|ed|ing)?\s+(?:its|their|the)\s+keep\b/giu
+  },
+  {
+    tell: "keeps X honest",
+    category: "claude-ism",
+    pattern: /\b(?:keep|keeps|keeping|kept)\s+(?:(?:this|that|us|me|things?)|(?:the|our|your|my)\s+[\w-]+(?:\s+[\w-]+){0,2})\s+honest\b/giu
+  },
+  {
+    tell: "belt-and-suspenders",
+    category: "claude-ism",
+    pattern: /\bbelt(?:[-‐‑‒–—\s]+)and(?:[-‐‑‒–—\s]+)suspenders\b/giu
+  },
+  {
+    tell: "soup to nuts",
+    category: "claude-ism",
+    pattern: /\b(?:from\s+)?soup(?:[-‐‑‒–—\s]+)to(?:[-‐‑‒–—\s]+)nuts\b/giu
+  },
+  {
+    tell: "architectural seam",
+    category: "claude-ism",
+    pattern: /\b(?:(?:clean|natural|architectural|implementation|integration)\s+seam|(?:at|across)\s+the\s+seam\s+between)\b/giu
+  },
+  // The apology/validation loop developers see after correcting an agent.
+  {
+    tell: "you're absolutely right",
+    category: "sycophancy",
+    pattern: /\byou(?:['’]re|\s+are)\s+absolutely\s+right\b/giu
+  },
+  {
+    tell: "you're right to call that out",
+    category: "sycophancy",
+    pattern: /\byou(?:['’]re|\s+are)\s+right\s+to\s+(?:call|point|flag)\s+(?:me|that|this)\s+out\b/giu
+  },
+  {
+    tell: "good question",
+    category: "sycophancy",
+    pattern: /\b(?:(?:that(?:['’]s|\s+is)|this\s+is)\s+)?(?:a\s+)?(?:good|great|excellent)\s+question\b/giu
+  },
+  {
+    tell: "good catch",
+    category: "sycophancy",
+    pattern: /\b(?:(?:that(?:['’]s|\s+is)|this\s+is)\s+)?(?:a\s+)?(?:good|great|excellent)\s+catch\b/giu
+  },
+  {
+    tell: "real gap",
+    category: "sycophancy",
+    pattern: /\b(?:a\s+)?real\s+gap\b/giu
+  },
+  {
+    tell: "error in my framing",
+    category: "sycophancy",
+    pattern: /\b(?:a\s+)?real\s+error\s+in\s+(?:my|the)\s+framing\b/giu
+  },
+  {
+    tell: "I was wrong",
+    category: "sycophancy",
+    pattern: /\bi\s+was\s+wrong\b/giu
+  },
+  {
+    tell: "I overcomplicated it",
+    category: "sycophancy",
+    pattern: /\bi\s+(?:overcomplicated|over-engineered|overthought)\s+(?:this|that|it)\b/giu
+  },
+  // Cross-model corporate/chatbot prose, constrained where a raw word is technical.
+  { tell: "delve", category: "stock prose", pattern: /\b(?:delve(?:d|s)?|delving)\b/giu },
+  { tell: "crucial", category: "stock prose", pattern: /\bcrucial\b/giu },
+  { tell: "pivotal", category: "stock prose", pattern: /\bpivotal\b/giu },
+  { tell: "tapestry", category: "stock prose", pattern: /\btapestr(?:y|ies)\b/giu },
+  {
+    tell: "here's the thing",
+    category: "stock prose",
+    pattern: /\bhere(?:['’]s|\s+is)\s+the\s+thing\b/giu
+  },
+  {
+    tell: "hope this helps",
+    category: "stock prose",
+    pattern: /\bhope\s+(?:this|that)\s+helps\b/giu
+  },
+  {
+    tell: "after careful consideration",
+    category: "stock prose",
+    pattern: /\bafter\s+careful\s+consideration\b/giu
+  },
+  {
+    tell: "quick update",
+    category: "stock prose",
+    pattern: /\bto\s+provide\s+(?:you\s+with\s+)?a\s+quick\s+update\b/giu
+  },
+  {
+    tell: "robust and reliable",
+    category: "stock prose",
+    pattern: /\brobust(?:\s+and|,)\s+reliable\b/giu
+  },
+  { tell: "seamless", category: "stock prose", pattern: /\bseamless(?:ly)?\b/giu },
+  {
+    tell: "in the realm of",
+    category: "stock prose",
+    pattern: /\b(?:in|within)\s+the\s+realm\s+of\b/giu
+  },
+  {
+    tell: "important to note",
+    category: "stock prose",
+    pattern: /\b(?:(?:it\s+is|it(?:['’]s))\s+)?important\s+to\s+note\b/giu
+  },
+  {
+    tell: "worth noting",
+    category: "stock prose",
+    pattern: /\b(?:(?:it\s+is|it(?:['’]s))\s+)?worth\s+noting\b/giu
+  },
+  {
+    tell: "let me break this down",
+    category: "stock prose",
+    pattern: /\blet\s+(?:me|us)\s+break\s+(?:this|it)\s+down\b/giu
+  },
+  {
+    tell: "let's dive in",
+    category: "stock prose",
+    pattern: /\blet(?:['’]s|\s+us)\s+dive\s+(?:in|into)\b/giu
+  },
+  {
+    tell: "let's unpack this",
+    category: "stock prose",
+    pattern: /\blet(?:['’]s|\s+us)\s+unpack\s+(?:this|that|it)\b/giu
+  },
+  { tell: "at its core", category: "stock prose", pattern: /\bat\s+its\s+core\b/giu },
+  {
+    tell: "comprehensive",
+    category: "stock prose",
+    pattern: /\bcomprehensive\s+(?:analysis|approach|coverage|error\s+handling|guide|implementation|overview|solution|suite)\b/giu
+  },
+  {
+    tell: "successfully implemented",
+    category: "stock prose",
+    pattern: /\bsuccessfully\s+(?:added|completed|created|fixed|implemented|resolved|updated)\b/giu
+  },
+  {
+    tell: "Certainly.",
+    category: "stock prose",
+    pattern: /(?:^|\n)[\t ]*certainly\b/gimu
+  },
+  {
+    tell: "I'd be happy to",
+    category: "stock prose",
+    pattern: /\bi(?:['’]d|\s+would)\s+be\s+happy\s+to\b/giu
+  },
+  // Corrective juxtaposition and fake-deep contrast templates.
+  {
+    tell: "it's not X, it's Y",
+    category: "rhetorical template",
+    pattern: /\b(?:it|this|that)(?:['’]s|\s+is)\s+not\s+[^.!?\n]{1,100}?(?:,|;|—)\s*(?:it|this|that)(?:['’]s|\s+is)\s+[^.!?\n]{1,100}/giu
+  },
+  {
+    tell: "it's not X, it's Y",
+    category: "rhetorical template",
+    pattern: /\b(?:it|this|that)\s+isn(?:['’]t)\s+[^.!?\n]{1,100}[.!;—]\s*(?:it|this|that)(?:['’]s|\s+is)\s+[^.!?\n]{1,100}/giu
+  },
+  {
+    tell: "not just X, but Y",
+    category: "rhetorical template",
+    pattern: /\bnot\s+just\s+[^.!?\n]{1,100}?,?\s+(?:but(?:\s+also)?|(?:it|this|that)(?:['’]s|\s+is))\s+[^.!?\n]{1,100}/giu
+  }
+];
+function detectSlop(text) {
+  const prose = maskMarkdownCode(text);
+  const candidates = SLOP_SIGNALS.flatMap((signal) => findSignalMatches(prose, signal));
+  addCheckmarkWall(prose, candidates);
+  const matches = longestNonOverlapping(candidates).map(({ end: _end, ...match }) => match);
+  return { count: matches.length, matches };
+}
+function findSignalMatches(text, signal) {
+  const matches = [];
+  signal.pattern.lastIndex = 0;
+  let match;
+  while ((match = signal.pattern.exec(text)) !== null) {
+    const bounds = trimmedBounds(match[0]);
+    if (bounds.text) {
+      const index = match.index + bounds.start;
+      matches.push({
+        tell: signal.tell,
+        text: bounds.text,
+        index,
+        end: index + bounds.text.length,
+        category: signal.category
+      });
+    }
+    if (match[0].length === 0) {
+      signal.pattern.lastIndex++;
+    }
+  }
+  return matches;
+}
+function trimmedBounds(value) {
+  const start = value.search(/\S/u);
+  if (start === -1) {
+    return { text: "", start: 0 };
+  }
+  return { text: value.trim(), start };
+}
+function maskMarkdownCode(text) {
+  return text.replace(/(?:```|~~~)[\s\S]*?(?:(?:```|~~~)|$)/gu, preserveNewlines).replace(/`[^`\n]+`/gu, preserveNewlines);
+}
+function preserveNewlines(value) {
+  return value.replace(/[^\n]/gu, " ");
+}
+function addCheckmarkWall(text, candidates) {
+  const checkmarks = Array.from(text.matchAll(/^[\t ]*(?:[-*]\s*)?[✅✓]\s+/gmu));
+  if (checkmarks.length < 3) {
+    return;
+  }
+  const first = checkmarks[0];
+  if (!first) {
+    return;
+  }
+  const offset = first[0].search(/[✅✓]/u);
+  const index = first.index + Math.max(offset, 0);
+  candidates.push({
+    tell: "checkmark wall",
+    text: `\u2705 \xD7${checkmarks.length}`,
+    index,
+    end: index + 2,
+    category: "formatting"
+  });
+}
+function longestNonOverlapping(candidates) {
+  const longestFirst = [...candidates].sort(
+    (left, right) => right.end - right.index - (left.end - left.index) || left.index - right.index || left.tell.localeCompare(right.tell)
+  );
+  const accepted = [];
+  for (const candidate of longestFirst) {
+    const overlaps = accepted.some(
+      (match) => candidate.index < match.end && candidate.end > match.index
+    );
+    if (!overlaps) {
+      accepted.push(candidate);
+    }
+  }
+  return accepted.sort((left, right) => left.index - right.index);
+}
+
 // src/commands/scan.ts
 var c = {
   reset: "\x1B[0m",
@@ -2955,6 +3299,14 @@ var COST_SPINNER_MESSAGES = [
   "Crunching token counts",
   "Still working through local history"
 ];
+var SLOP_SPINNER_MESSAGES = [
+  "Auditing agent prose",
+  "Counting load-bearing insights",
+  "Inspecting suspiciously honest takes",
+  "Measuring corrective juxtaposition",
+  "Checking what earned its keep",
+  "Cataloging chatbot tics"
+];
 var DAY_MS = 24 * 60 * 60 * 1e3;
 function createSpinner(messages = SPINNER_MESSAGES) {
   let messageIdx = 0;
@@ -2994,7 +3346,7 @@ function createSpinner(messages = SPINNER_MESSAGES) {
     }
   };
 }
-function parseArgs(args) {
+function parseArgs(args, command = "scan") {
   const options = {};
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -3016,7 +3368,18 @@ function parseArgs(args) {
     } else if (arg === "--month") {
       setRelativeRange(options, 30);
     } else if (arg === "--help" || arg === "-h") {
-      console.log(`devrage scan \u2014 scan sessions for profanity
+      if (command === "slop") {
+        console.log(`devrage slop \u2014 scan coding-agent responses for AI-isms
+
+Options:
+  --agent, -a <name>   Scan only a specific agent (claude, codex, cursor, opencode, amp, cline, pi, t3code, zed)
+  --since, -s <date>   Only scan responses after this date (ISO 8601)
+  --day, --days [n]    Only scan the last n days (default: 1)
+  --week               Only scan the last 7 days
+  --month              Only scan the last 30 days
+  --help, -h           Show this help`);
+      } else {
+        console.log(`devrage scan \u2014 scan sessions for profanity
 
 Options:
   --agent, -a <name>   Scan only a specific agent (claude, codex, cursor, opencode, amp, cline, pi, t3code, zed)
@@ -3025,6 +3388,7 @@ Options:
   --week               Only scan the last 7 days
   --month              Only scan the last 30 days
   --help, -h           Show this help`);
+      }
       process.exit(0);
     }
   }
@@ -3169,6 +3533,98 @@ async function scan(args) {
     console.log("");
   }
 }
+async function slop(args) {
+  const options = parseArgs(args, "slop");
+  const adapters = options.agent ? [createAdapter(options.agent)] : allAdapters();
+  const spinner = createSpinner(SLOP_SPINNER_MESSAGES);
+  const tellTally = {};
+  const categoryTally = {};
+  const perAgent = {};
+  let totalMessages = 0;
+  let totalHits = 0;
+  let taintedMessages = 0;
+  spinner.start();
+  try {
+    for (const adapter of adapters) {
+      let agentMessages = 0;
+      let agentHits = 0;
+      let agentTainted = 0;
+      spinner.update();
+      for await (const message of adapter.messages({
+        role: "assistant",
+        since: options.since
+      })) {
+        totalMessages++;
+        agentMessages++;
+        const result = detectSlop(message.text);
+        if (result.count === 0) {
+          continue;
+        }
+        totalHits += result.count;
+        agentHits += result.count;
+        taintedMessages++;
+        agentTainted++;
+        for (const match of result.matches) {
+          tellTally[match.tell] = (tellTally[match.tell] ?? 0) + 1;
+          categoryTally[match.category] = (categoryTally[match.category] ?? 0) + 1;
+        }
+      }
+      if (agentMessages > 0) {
+        perAgent[adapter.name] = {
+          messages: agentMessages,
+          hits: agentHits,
+          tainted: agentTainted
+        };
+      }
+    }
+  } finally {
+    spinner.stop();
+  }
+  const activeAgents = Object.entries(perAgent);
+  console.log("");
+  printReportHeader(options, "slop");
+  printSlopOverview(totalMessages, totalHits, taintedMessages);
+  if (activeAgents.length > 1) {
+    console.log("");
+    console.log(`  ${sectionTitle("agent slop")}`);
+    for (const [name, stats] of activeAgents) {
+      const rate = stats.messages > 0 ? stats.tainted / stats.messages : 0;
+      console.log(
+        `    ${colorText(name.padEnd(10), agentColor(name))} ${c.bold}${String(stats.hits).padStart(4)}${c.reset} ${c.dim}hits \xB7 ${stats.tainted}/${stats.messages} messages (${formatPercent(rate)})${c.reset}`
+      );
+    }
+  }
+  if (totalHits > 0) {
+    const tells = Object.entries(tellTally).sort(
+      ([left, leftCount], [right, rightCount]) => rightCount - leftCount || left.localeCompare(right)
+    );
+    console.log("");
+    console.log(`  ${sectionTitle("top tells")}`);
+    for (const [tell, count] of tells.slice(0, 15)) {
+      console.log(
+        `    ${c.yellow}${tell.padEnd(28)}${c.reset} ${c.bold}${String(count).padStart(4)}${c.reset}`
+      );
+    }
+    const categories = Object.entries(categoryTally).sort(
+      ([left, leftCount], [right, rightCount]) => (rightCount ?? 0) - (leftCount ?? 0) || left.localeCompare(right)
+    );
+    console.log("");
+    console.log(`  ${sectionTitle("slop flavors")}`);
+    for (const [category, count] of categories) {
+      console.log(
+        `    ${c.cyan}${category.padEnd(28)}${c.reset} ${c.bold}${String(count).padStart(4)}${c.reset}`
+      );
+    }
+  }
+  console.log("");
+  if (totalMessages === 0) {
+    console.log(`  ${c.gray}no assistant messages found.${c.reset}`);
+    console.log("");
+  } else if (totalHits === 0) {
+    console.log(`  ${c.green}suspiciously human. not a single slop tell found.${c.reset}`);
+    console.log("");
+  }
+}
 async function cost(args) {
   const options = parseCostArgs(args);
   const adapters = options.agent ? [createAdapter(options.agent)] : allAdapters();
@@ -3562,13 +4018,25 @@ function renderCostHtmlReport(data) {
 function jsonForScript(value) {
   return JSON.stringify(value).replace(/</g, "\\u003c");
 }
-function printReportHeader(options) {
+function printReportHeader(options, label = "report") {
   const scope = options.rangeLabel ?? (options.since ? `since ${formatDate(options.since)}` : "all local history");
   const agent = options.agent ? ` \xB7 ${options.agent}` : "";
-  console.log(`  ${c.bold}${c.red}devrage${c.reset} ${c.dim}report${c.reset}`);
+  console.log(`  ${c.bold}${c.red}devrage${c.reset} ${c.dim}${label}${c.reset}`);
   console.log(`  ${c.dim}${scope}${agent}${c.reset}`);
   console.log(`  ${c.dim}${"\u2500".repeat(54)}${c.reset}`);
 }
+function printSlopOverview(totalMessages, totalHits, taintedMessages) {
+  const rate = totalMessages > 0 ? taintedMessages / totalMessages : 0;
+  console.log(
+    `  ${c.dim}assistant messages${c.reset} ${c.bold}${formatNumber(totalMessages)}${c.reset}`
+  );
+  console.log(
+    `  ${c.dim}slop hits${c.reset}          ${c.bold}${c.yellow}${formatNumber(totalHits)}${c.reset}`
+  );
+  console.log(
+    `  ${c.dim}messages with slop${c.reset} ${c.bold}${formatNumber(taintedMessages)}${c.reset} ${c.dim}(${formatPercent(rate)})${c.reset}`
+  );
+}
 function printBasicOverview(totalMessages, totalSwears) {
   console.log(
     `  ${c.dim}messages scanned${c.reset}   ${c.bold}${formatNumber(totalMessages)}${c.reset}`
@@ -3696,11 +4164,12 @@ function formatDate(value) {
 // src/cli.ts
 var COMMANDS = {
   cost,
-  scan
+  scan,
+  slop
 };
 var OPTIONS_WITH_VALUES = /* @__PURE__ */ new Set(["--agent", "-a", "--since", "-s"]);
 function usage() {
-  console.log(`devrage \u2014 count how many times you swear at your coding agents
+  console.log(`devrage \u2014 measure rage, cost, and AI slop in coding-agent sessions
 
 Usage:
   devrage <command> [options]
@@ -3708,6 +4177,7 @@ Usage:
 Commands:
   cost          Show API-equivalent coding agent cost
   scan          Scan sessions for profanity
+  slop          Scan agent responses for common AI-isms
 
 Options:
   --help, -h    Show this help message
@@ -3716,7 +4186,9 @@ Options:
 Examples:
   devrage cost
   devrage scan
+  devrage slop
   devrage scan --agent claude
+  devrage slop --agent codex
   devrage scan --since 2025-01-01`);
 }
 async function main() {
@@ -3727,7 +4199,7 @@ async function main() {
     process.exit(0);
   }
   if (command === "--version") {
-    console.log("0.5.7");
+    console.log("0.6.0");
     process.exit(0);
   }
   const parsed = parseCommand(args);