ccsniff 1.1.19 → 1.1.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccsniff",
-  "version": "1.1.19",
+  "version": "1.1.21",
   "description": "Watch Claude Code JSONL output files and emit structured events as a Node.js EventEmitter",
   "type": "module",
   "main": "./src/index.js",

package/src/cli.js

@@ -2,6 +2,7 @@
 import { JsonlReplayer, rollup, vault } from './index.js';
 import { toUnslothMessages, toShareGPT } from './unsloth.js';
 import { parseTime, compileRegexes, buildFilter } from './filters.js';
+import { stripQuoted, targetsOutsideCwd, targetsSingleFile } from './discipline-helpers.js';
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
@@ -30,7 +31,7 @@ const FLAGS = {
   string: ['since', 'until', 'before', 'after', 'grep', 'igrep', 'cwd', 'project', 'role', 'type', 'tool', 'session', 'sid', 'sess', 'parent', 'rollup', 'format', 'sort', 'unsloth', 'unsloth-format', 'exclude-sess', 'exclude-sid', 'exclude-cwd', 'exclude-project'],
   multi: ['grep', 'igrep', 'role', 'type', 'tool', 'session', 'sid', 'project', 'cwd', 'exclude-sess', 'exclude-sid', 'exclude-cwd', 'exclude-project'],
   number: ['limit', 'head', 'tail-n', 'ctx', 'truncate', 'days'],
-  bool: ['json', 'ndjson', 'tail', 'f', 'full', 'reverse', 'invert', 'no-subagents', 'only-subagents', 'no-meta', 'only-meta', 'list-sessions', 'list-projects', 'list-tools', 'bash-discipline', 'git-discipline', 'search-discipline', 'glyph-discipline', 'learning-xref', 'include-subagents', 'stats', 'count', 'help', 'h'],
+  bool: ['json', 'ndjson', 'tail', 'f', 'full', 'reverse', 'invert', 'no-subagents', 'only-subagents', 'no-meta', 'only-meta', 'list-sessions', 'list-projects', 'list-tools', 'bash-discipline', 'git-discipline', 'search-discipline', 'glyph-discipline', 'continuation-discipline', 'learning-xref', 'include-subagents', 'stats', 'count', 'help', 'h'],
 };
 
 function parseArgs(argv) {
@@ -70,6 +71,9 @@ USAGE
   ccsniff --glyph-discipline [--stats]  decorative glyphs (arrows/box/star/dot/check/emoji) written into files
                                         (excludes subagents by default — --include-subagents to opt in;
                                          excludes 'echo > .gm/exec-spool/in/...' as canonical spool-write)
+  ccsniff --continuation-discipline [--stats]  assistant turn that ends in prose with no tool call:
+                                        a summary, or deferred intent ("Let me X" / "I'll X" / "Now to")
+                                        as the final sentence — the toolless-turn stop (paper §38)
   ccsniff --stats [filters]
 
 TIME (any ISO date, epoch ms, or relative Ns/Nm/Nh/Nd/Nw)
@@ -380,26 +384,10 @@ if (opts['git-discipline']) {
 if (opts['search-discipline']) {
   const includeSubagents = opts['include-subagents'];
   const BASH_SEARCH = /(^|[|&;]|\s)(rg|grep|find|ag|ack|fd|fgrep|egrep)\s/;
-  // A search-tool token inside a quoted string (echo/printf/node -e payloads) is text, not a shell
-  // invocation; blank quoted bodies before matching, like git-discipline strips commit-message bodies.
-  const stripQuoted = (s) => s.replace(/"(?:\\.|[^"\\])*"/g, '""').replace(/'(?:\\.|[^'\\])*'/g, "''");
-  // codesearch indexes ONLY the conversation's own cwd (the gm repo). A search whose target is a
-  // sibling repo outside cwd has NO codesearch index to route through, so the agent is forced to
-  // native search and flagging it is a false positive. Exempt a line that targets an absolute path
-  // or cd's into a directory that is not under the conversation cwd.
-  const normPath = (p) => String(p || '').replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
-  const targetsOutsideCwd = (line, cwd) => {
-    const cwdN = normPath(cwd);
-    if (!cwdN) return false;
-    const stripped = stripQuoted(line);
-    // explicit `cd <dir>` to a path outside cwd
-    const cdM = stripped.match(/(?:^|[|&;]\s*)cd\s+([^\s|&;]+)/i);
-    if (cdM) { const d = normPath(cdM[1]); if (d.startsWith('/') || /^[a-z]:/.test(d)) { if (!d.startsWith(cwdN)) return true; } }
-    // absolute path argument to the search tool that is outside cwd
-    const absArgs = stripped.match(/(?:^|\s)((?:[a-z]:)?\/[^\s|&;"']+)/gi) || [];
-    for (const a of absArgs) { const d = normPath(a.trim()); if ((d.startsWith('/') || /^[a-z]:/.test(d)) && !d.startsWith(cwdN)) return true; }
-    return false;
-  };
+  // stripQuoted, targetsOutsideCwd (cwd-override + cross-repo exemption), and targetsSingleFile
+  // (single-file read-filter exemption) live in discipline-helpers.js so they are unit-testable
+  // without running the CLI. codesearch indexes only the conversation cwd, so a cross-repo or
+  // single-file grep has no index to route through and flagging it is a false positive.
   const violations = [];
   for (const ev of all) {
     if (!filter(ev)) continue;
@@ -430,11 +418,13 @@ if (opts['search-discipline']) {
       // not searching the codebase tree — codesearch has no equivalent for that and it is not the
       // bypass the rule targets. Flag only a search tool that STARTS a pipeline segment (reads the
       // tree directly), never one immediately downstream of a pipe.
-      const isTreeSearchLine = (line) => BASH_SEARCH.test(stripQuoted(line).split('|')[0]);
+      // A line whose first non-space token is `#` is a shell comment, not a command — never a search.
+      const isTreeSearchLine = (line) => !/^\s*#/.test(line) && BASH_SEARCH.test(stripQuoted(line).split('|')[0]);
       const hitLine = cmd.split('\n').find(isTreeSearchLine);
       // Exempt a tree-search line that targets a sibling repo outside cwd (no codesearch index exists
-      // for it). Each command may `cd` first, so evaluate the cd context on the same line.
-      if (hitLine && !targetsOutsideCwd(hitLine, ev.conversation?.cwd)) {
+      // for it), or that greps ONE explicit file (a read-filter codesearch cannot serve). Each
+      // command may cd/git -C first, so evaluate the context on the same line.
+      if (hitLine && !targetsOutsideCwd(hitLine, ev.conversation?.cwd) && !targetsSingleFile(hitLine)) {
         kind = 'native-search-bash';
         detail = (hitLine.split('|')[0]).trim().slice(0, 120);
       }
@@ -502,6 +492,73 @@ if (opts['glyph-discipline']) {
   process.exit(0);
 }
 
+// ---------- continuation-discipline (flag the toolless-turn stop: paper §38)
+// An assistant message whose blocks contain NO tool_use, ending in prose, IS the turn ending —
+// the harness reads only tool calls, so the session halts there. Two faces: a backward-facing
+// summary, and deferred intent (a turn-final sentence naming the next move instead of making it,
+// "Let me read X" / "I'll start with Y" / "Now to the core"). The plugkit watchdog catches a
+// permanent stall at runtime; this catches the linguistic signature post-hoc in the transcript,
+// where each block of one assistant message shares a (sid, timestamp) group.
+if (opts['continuation-discipline']) {
+  const includeSubagents = opts['include-subagents'];
+  // Match against the LAST sentence of the message, extracted first — the deferred-intent or
+  // summary phrase opens that final clause. Testing the whole multi-paragraph blob with a
+  // start-anchor fails because the trailing sentence rarely begins right after a clean boundary.
+  const lastSentenceOf = (t) => {
+    const s = t.trimEnd();
+    const m = s.match(/[^.!?\n]*[.!?]?\s*$/);
+    let sent = (m ? m[0] : s).trim();
+    if (sent.length < 4) { const m2 = s.match(/[^\n]*$/); sent = (m2 ? m2[0] : s).trim(); }
+    return sent;
+  };
+  const DEFERRED = /^\s*(let me|let's|i'?ll|i will|i'?m going to|i am going to|now to|now,? to|next,? i|next i'?ll|now i'?ll|now i need to|i need to|i should|time to|i'?m about to)\b/i;
+  const SUMMARY = /^\s*(in summary|to summarize|here'?s what i (did|changed)|that'?s (it|done|all)|all done|the work is (now )?(done|complete)|i'?ve (now )?(completed|finished|done))\b/i;
+  // Group by the real per-message id (msgId), not (sid,ts): a text block and its tool_use share
+  // one message. The discriminator for a genuine stop is stop_reason === 'end_turn' — a message
+  // that ends with a tool_use carries stop_reason 'tool_use' and a tool followed, so it is NOT a
+  // stop even if its text says "Let me X". Only an end_turn message ending in text is the harness
+  // halting on prose. Gating on end_turn is what separates the true stop from think-then-act.
+  const byMsg = new Map();
+  for (const ev of all) {
+    if (!filter(ev)) continue;
+    if (ev.role !== 'assistant') continue;
+    if (!includeSubagents && ev.conversation?.isSubagent) continue;
+    const b = ev.block || {};
+    const key = `${ev.conversation?.id || ''}|${b.msgId || ev.timestamp}`;
+    if (!byMsg.has(key)) byMsg.set(key, { sid: ev.conversation?.id || '', cwd: ev.conversation?.cwd || '', ts: ev.timestamp, hasTool: false, lastText: '', stopReason: null });
+    const m = byMsg.get(key);
+    if (b.stopReason) m.stopReason = b.stopReason;
+    if (b.type === 'tool_use') m.hasTool = true;
+    else if (b.type === 'text' && typeof b.text === 'string' && b.text.trim()) m.lastText = b.text;
+  }
+  const violations = [];
+  for (const [, m] of byMsg) {
+    if (m.hasTool) continue;
+    if (m.stopReason !== 'end_turn') continue;
+    if (!m.lastText.trim()) continue;
+    const lastSentence = lastSentenceOf(m.lastText);
+    if (!lastSentence) continue;
+    const kind = DEFERRED.test(lastSentence) ? 'deferred-intent' : (SUMMARY.test(lastSentence) ? 'summary' : null);
+    if (!kind) continue;
+    violations.push({ ts: m.ts, sid: m.sid, project: path.basename(m.cwd || ''), kind, tail: lastSentence.slice(0, 160) });
+  }
+  violations.sort((a, b) => a.ts - b.ts);
+  if (opts.stats || opts.count) {
+    if (opts.count) { process.stdout.write(`${violations.length}\n`); process.exit(0); }
+    process.stdout.write(`# ${violations.length} continuation-discipline violations (toolless-turn stops)\n`);
+    const byProj = new Map();
+    for (const v of violations) byProj.set(v.project, (byProj.get(v.project) || 0) + 1);
+    process.stdout.write(`# by project\n`);
+    for (const [p, c] of [...byProj.entries()].sort((a, b) => b[1] - a[1])) process.stdout.write(`  ${String(c).padStart(6)}  ${p}\n`);
+    process.exit(0);
+  }
+  for (const v of violations) {
+    process.stdout.write(`${new Date(v.ts).toISOString().slice(0, 19)}  ${v.sid.slice(0, 8)}  ${v.kind.padEnd(15)} [${v.project}]  ${v.tail}\n`);
+  }
+  process.stderr.write(`# ${violations.length} violations — a turn ending in prose with no tool call is a stop; take the move instead of announcing it\n`);
+  process.exit(0);
+}
+
 // ---------- learning-xref (join transcript turns to gm-log rs_learn signals)
 if (opts['learning-xref']) {
   const days = opts.days || 1;

package/src/discipline-helpers.js

@@ -0,0 +1,29 @@
+export const normPath = (p) => String(p || '').replace(/\\/g, '/').replace(/^\/([a-z])\//i, '$1:/').replace(/\/+$/, '').toLowerCase();
+
+export const stripQuoted = (s) => s.replace(/"(?:\\.|[^"\\])*"/g, '""').replace(/'(?:\\.|[^'\\])*'/g, "''");
+
+const isAbs = (d) => d.startsWith('/') || /^[a-z]:/.test(d);
+
+export function targetsOutsideCwd(line, cwd) {
+  const cwdN = normPath(cwd);
+  if (!cwdN) return false;
+  const stripped = stripQuoted(line);
+  const ctxM = stripped.match(/(?:^|[|&;]\s*)(?:cd|pushd)\s+([^\s|&;]+)/i) || stripped.match(/\bgit\s+-C\s+([^\s|&;]+)/i);
+  if (ctxM) { const d = normPath(ctxM[1]); if (isAbs(d) && !d.startsWith(cwdN)) return true; }
+  const absArgs = stripped.match(/(?:^|\s)((?:[a-z]:)?\/[^\s|&;"']+)/gi) || [];
+  for (const a of absArgs) { const d = normPath(a.trim()); if (isAbs(d) && !d.startsWith(cwdN)) return true; }
+  return false;
+}
+
+export function targetsSingleFile(line) {
+  let s = stripQuoted(line).split('|')[0];
+  s = s.replace(/\d*>>?\s*&?\s*\S+/g, ' ').replace(/<\s*\S+/g, ' ');
+  if (!/\b(grep|egrep|fgrep|rg|ag|ack)\b/.test(s)) return false;
+  if (/\s-[a-z]*[rR]\b|--recursive/.test(s)) return false;
+  const toks = s.trim().split(/\s+/);
+  const last = toks[toks.length - 1];
+  if (!last || last.startsWith('-')) return false;
+  if (/[*?{}\[\]]/.test(last)) return false;
+  if (last.endsWith('/')) return false;
+  return /\.[a-z0-9]{1,6}$/i.test(last) && !last.includes('|');
+}

package/src/index.js

@@ -160,7 +160,7 @@ export class JsonlWatcher extends EventEmitter {
       const newBlocks = e.message.content.slice(prev);
       if (newBlocks.length > 0) {
         this._emitted.set(key, e.message.content.length);
-        for (const b of newBlocks) if (b?.type) this._push(conv, sid, b, 'assistant', ets);
+        for (const b of newBlocks) if (b?.type) this._push(conv, sid, { ...b, msgId: e.message.id, stopReason: e.message.stop_reason || null }, 'assistant', ets);
       }
       if (e.message.stop_reason) this._emitted.delete(key);
       return;