cc-transcript 14.23.0__tar.gz → 14.25.0__tar.gz

{cc_transcript-14.23.0 → cc_transcript-14.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-transcript
-Version: 14.23.0
+Version: 14.25.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{cc_transcript-14.23.0 → cc_transcript-14.25.0}/cc_transcript/__init__.py

@@ -234,6 +234,8 @@ EXPORTS: dict[str, str] = {
             "SchemaError",
             "TurnRef",
             "capture_window",
+            "capture_windows",
+            "hydrate_windows",
         ),
         "cc_transcript.render": ("Budget", "render_session", "render_tool_call", "render_turn"),
         "cc_transcript.notifications": ("Notifications",),

{cc_transcript-14.23.0 → cc_transcript-14.25.0}/cc_transcript/__init__.pyi

@@ -54,6 +54,8 @@ from cc_transcript.context import (
     SchemaError as SchemaError,
     TurnRef as TurnRef,
     capture_window as capture_window,
+    capture_windows as capture_windows,
+    hydrate_windows as hydrate_windows,
 )
 
 from cc_transcript.corrections import (
@@ -467,6 +469,7 @@ __all__ = [
     "build_spec",
     "canonical_json",
     "capture_window",
+    "capture_windows",
     "command_prefix_counts",
     "command_prefixes",
     "cost_of",
@@ -491,6 +494,7 @@ __all__ = [
     "harvest_pairs",
     "hunk_overlap",
     "hunks_of",
+    "hydrate_windows",
     "keep",
     "keep_only",
     "labels_for",

{cc_transcript-14.23.0 → cc_transcript-14.25.0}/cc_transcript/_native.pyi

@@ -120,6 +120,7 @@ __all__ = [
     "command_parse",
     "command_prefixes",
     "context_capture_window",
+    "context_capture_windows",
     "context_render_preview",
     "context_roundtrip",
     "cost_of_json",
@@ -2330,6 +2331,8 @@ def command_prefixes(commands: typing.Sequence[builtins.str]) -> builtins.list[b
 
 def context_capture_window(raw: bytes, session_id: builtins.str, anchor_uuid: builtins.str, anchor_tool_use_id: typing.Optional[builtins.str], before: builtins.int, after: builtins.int, preview_chars: builtins.int) -> builtins.str: ...
 
+def context_capture_windows(raw: bytes, anchors: typing.Sequence[tuple[builtins.str, builtins.str, typing.Optional[builtins.str]]], before: builtins.int, after: builtins.int, preview_chars: builtins.int) -> builtins.list[builtins.str]: ...
+
 def context_render_preview(data: builtins.str, turn_chars: builtins.int) -> builtins.str: ...
 
 def context_roundtrip(data: builtins.str) -> builtins.str: ...

{cc_transcript-14.23.0 → cc_transcript-14.25.0}/cc_transcript/context.py

@@ -21,7 +21,7 @@ from cc_transcript.models import Question
 from cc_transcript.render import Budget, clip, render_turn
 
 if TYPE_CHECKING:
-    from collections.abc import Mapping
+    from collections.abc import Mapping, Sequence
     from typing import Any
 
     from cc_transcript.activity import Turn
@@ -158,17 +158,7 @@ class ContextWindow:
             away — callers fall back to :meth:`render_preview`, never
             hydrate-or-fail.
         """
-        try:
-            activity = SessionActivity.from_session(self.anchor.session_id)
-        except TranscriptExpiredError:
-            return None
-        turns: list[Turn] = []
-        for turn_ref in window_refs(self):
-            resolved = [turn for ref in turn_ref.refs if (turn := activity.turn_of(ref)) is not None]
-            if len(resolved) != len(turn_ref.refs) or not resolved:
-                return None
-            turns.append(resolved[0])
-        return HydratedWindow(window=self, turns=tuple(turns))
+        return hydrate_windows((self,))[0]
 
     def to_json(self) -> str:
         """Serialize to the ``cc-transcript.context/2`` wire schema, byte-stably.
@@ -259,11 +249,65 @@ def capture_window(
     Raises:
         ValueError: When ``anchor`` does not resolve within ``raw``.
     """
-    return ContextWindow.from_json(
-        _native.context_capture_window(
-            raw, anchor.session_id, anchor.event_uuid, anchor.tool_use_id, before, after, preview_chars
+    return capture_windows(raw, (anchor,), before=before, after=after, preview_chars=preview_chars)[0]
+
+
+def capture_windows(
+    raw: bytes,
+    anchors: Sequence[EventRef],
+    *,
+    before: int = 6,
+    after: int = 2,
+    preview_chars: int = 200,
+) -> list[ContextWindow]:
+    """Capture ordered windows with one parse and one activity lift per session.
+
+    Uses the same budgets and anchor resolution as :func:`capture_window`.
+    An empty batch returns without parsing; any unresolved anchor raises
+    ValueError for the entire batch.
+    """
+    return [
+        ContextWindow.from_json(data)
+        for data in _native.context_capture_windows(
+            raw,
+            [(anchor.session_id, anchor.event_uuid, anchor.tool_use_id) for anchor in anchors],
+            before,
+            after,
+            preview_chars,
         )
-    )
+    ]
+
+
+def hydrate_windows(windows: Sequence[ContextWindow]) -> list[HydratedWindow | None]:
+    """Resolve an ordered batch, loading each session at most once.
+
+    Missing transcripts and compacted references yield None at that window's
+    position. The batch owns its reads; no parsed-session cache persists
+    between calls, so a later call observes transcript changes.
+    """
+    sessions: dict[SessionId, list[tuple[int, ContextWindow]]] = {}
+    for index, window in enumerate(windows):
+        sessions.setdefault(window.anchor.session_id, []).append((index, window))
+    hydrated: list[HydratedWindow | None] = [None] * len(windows)
+    for session_id, batch in sessions.items():
+        try:
+            activity = SessionActivity.from_session(session_id)
+        except TranscriptExpiredError:
+            continue
+        for index, window in batch:
+            hydrated[index] = hydrate_from_activity(window, activity)
+        del activity
+    return hydrated
+
+
+def hydrate_from_activity(window: ContextWindow, activity: SessionActivity) -> HydratedWindow | None:
+    turns: list[Turn] = []
+    for turn_ref in window_refs(window):
+        resolved = [turn for ref in turn_ref.refs if (turn := activity.turn_of(ref)) is not None]
+        if len(resolved) != len(turn_ref.refs) or not resolved:
+            return None
+        turns.append(resolved[0])
+    return HydratedWindow(window=window, turns=tuple(turns))
 
 
 def window_refs(window: ContextWindow) -> tuple[TurnRef, ...]:

{cc_transcript-14.23.0 → cc_transcript-14.25.0}/cc_transcript/render.py

@@ -62,7 +62,11 @@ def prefixed(prefix: str, text: str) -> tuple[str, ...]:
 
 
 def render_turn(turn: Turn, *, budget: Budget, tool_results: bool = False) -> str:
-    """Render one turn: the prompt, the user's mid-turn messages, assistant prose, and every tool call, in order.
+    """Render one turn: the prompt, the messages queued mid-turn, assistant prose, and every tool call, in order.
+
+    A message queued while the agent worked renders under who sent it: ``user:`` for
+    the user's own, ``notification:`` for a background task's, ``peer:`` for another
+    agent's, ``channel:`` for an MCP channel's.
 
     Prose chunks clip to ``budget.turn_chars``; each tool call renders via
     :func:`render_tool_call` under ``budget.tool_chars``. An AskUserQuestion answer

{cc_transcript-14.23.0 → cc_transcript-14.25.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "14.23.0" # informational — releases stamp the version from the git tag
+version = "14.25.0" # informational — releases stamp the version from the git tag
 description = "Grep every Claude Code session you've ever run."
 readme = "README.md"
 license = "PolyForm-Noncommercial-1.0.0"

cc_transcript-14.25.0/rust/crates/cli/src/commands/corpus.rs

@@ -0,0 +1,124 @@
+//! `corpus`: flatten a whole sweep into one deduped file of character windows, so the
+//! questions that follow grep the extract instead of re-reading every transcript.
+
+use std::collections::HashSet;
+use std::fs::File;
+use std::io::{BufWriter, Write};
+use std::path::PathBuf;
+
+use cc_transcript_core::render::haystack;
+use regex::Regex;
+
+use crate::commands::grep::{compile_pattern, where_flags};
+use crate::output::{click_error, eline, CliExit};
+use crate::target::{map_transcripts, py_path, require_files, resolve_targets};
+use crate::DiscoveryOpts;
+
+const USAGE: &str = "cc-transcript corpus [OPTIONS] --out <OUT> PATTERN [PATHS]...";
+const HELP_PATH: &str = "cc-transcript corpus";
+
+pub struct CorpusArgs {
+    pub pattern: String,
+    pub paths: Vec<PathBuf>,
+    pub discovery: DiscoveryOpts,
+    pub wheres: Vec<String>,
+    pub ignore_case: bool,
+    pub window: usize,
+    pub out: PathBuf,
+}
+
+/// Byte offset of the `window`th character before `at`, or the start of `text`.
+fn window_start(text: &str, at: usize, window: usize) -> usize {
+    match window.checked_sub(1) {
+        None => at,
+        Some(back) => text[..at]
+            .char_indices()
+            .rev()
+            .nth(back)
+            .map_or(0, |(index, _)| index),
+    }
+}
+
+/// Byte offset just past the `window`th character after `at`, or the end of `text`.
+fn window_end(text: &str, at: usize, window: usize) -> usize {
+    text[at..]
+        .char_indices()
+        .nth(window)
+        .map_or(text.len(), |(index, _)| at + index)
+}
+
+/// One window per line: line breaks inside a window become their two-character escapes,
+/// the shape `grep --corpus` then reads back.
+fn flatten(window: &str) -> String {
+    window.replace('\n', "\\n").replace('\r', "\\r")
+}
+
+fn windows_in(text: &str, regex: &Regex, window: usize) -> Vec<String> {
+    regex
+        .find_iter(text)
+        .map(|hit| {
+            flatten(
+                &text[window_start(text, hit.start(), window)..window_end(text, hit.end(), window)],
+            )
+        })
+        .collect()
+}
+
+pub fn run(args: CorpusArgs) -> Result<(), CliExit> {
+    let regex = compile_pattern(&args.pattern, args.ignore_case, USAGE, HELP_PATH)?;
+    let (w_text, w_thinking, w_tools) = where_flags(&args.wheres);
+    let paths: Vec<PathBuf> = args
+        .paths
+        .iter()
+        .map(|p| py_path(&p.to_string_lossy()))
+        .collect();
+    require_files(&paths, "'[PATHS]...'", USAGE, HELP_PATH)?;
+    let targets = resolve_targets(
+        &paths,
+        &args.discovery.validated_root(USAGE, HELP_PATH)?,
+        args.discovery.project.as_deref(),
+        args.discovery.contains.as_deref(),
+        args.discovery.sweep_limit(),
+        None,
+    )?;
+    let per_file = map_transcripts(&targets.paths, |parsed| {
+        parsed
+            .entries
+            .iter()
+            .flat_map(|event| {
+                windows_in(
+                    &haystack(event, w_text, w_thinking, w_tools),
+                    &regex,
+                    args.window,
+                )
+            })
+            .collect::<Vec<String>>()
+    });
+    let file = File::create(&args.out)
+        .map_err(|e| click_error(&format!("{}: {e}", args.out.display())))?;
+    let mut out = BufWriter::new(file);
+    let mut seen: HashSet<String> = HashSet::new();
+    let mut duplicates = 0usize;
+    let mut bytes = 0usize;
+    for line in per_file.into_iter().flatten() {
+        if !seen.insert(line.clone()) {
+            duplicates += 1;
+            continue;
+        }
+        out.write_all(line.as_bytes())
+            .and_then(|()| out.write_all(b"\n"))
+            .map_err(|e| click_error(&format!("{}: {e}", args.out.display())))?;
+        bytes += line.len() + 1;
+    }
+    out.flush()
+        .map_err(|e| click_error(&format!("{}: {e}", args.out.display())))?;
+    eline(&format!(
+        "{} files scanned, {} windows kept, {duplicates} duplicates dropped, {bytes} bytes written",
+        targets.paths.len(),
+        seen.len()
+    ));
+    if seen.is_empty() {
+        return Err(CliExit(1));
+    }
+    Ok(())
+}

{cc_transcript-14.23.0 → cc_transcript-14.25.0}/rust/crates/cli/src/commands/grep.rs

@@ -1,35 +1,39 @@
 //! cli.py `grep`.
 
 use std::collections::HashMap;
-use std::path::PathBuf;
+use std::fs::File;
+use std::io::{BufRead, BufReader};
+use std::path::{Path, PathBuf};
 
 use cc_transcript_core::facts::{tool_facts, ToolFact};
 use cc_transcript_core::filter::event_kind;
 use cc_transcript_core::render::{
-    compact_line, event_json, haystack, tool_haystack, transcript_header, Json,
+    compact_line, display_path, event_json, haystack, tool_haystack, transcript_header, Json,
 };
 use cc_transcript_core::toolcall::tool_name_matches;
 use cc_transcript_core::types::{ContentBlock, Entry};
 use regex::{Regex, RegexBuilder};
 
-use crate::output::{usage_error, CliExit, Out};
+use crate::output::{click_error, eline, usage_error, CliExit, Out};
 use crate::target::{parse_transcripts, py_path, resolve_targets, scope_note, tool_names, Parsed};
 use crate::DiscoveryOpts;
 
 const USAGE: &str = "cc-transcript grep [OPTIONS] PATTERN [PATHS]...";
 const HELP_PATH: &str = "cc-transcript grep";
+const DEFAULT_MAX_MATCHES: usize = 20;
 
 pub struct GrepArgs {
     pub pattern: String,
     pub paths: Vec<PathBuf>,
     pub discovery: DiscoveryOpts,
+    pub corpus: Option<PathBuf>,
     pub kinds: Vec<String>,
     pub tool: Option<String>,
     pub errors: bool,
     pub ignore_case: bool,
     pub wheres: Vec<String>,
     pub context: usize,
-    pub max_matches: usize,
+    pub max_matches: Option<usize>,
     pub width: usize,
     pub uuids: bool,
     pub with_result: bool,
@@ -141,11 +145,78 @@ fn merge_windows(hits: &[usize], context: usize, size: usize) -> Vec<(usize, usi
     merged
 }
 
-fn compile_pattern(pattern: &str, ignore_case: bool) -> Result<Regex, CliExit> {
+pub fn compile_pattern(
+    pattern: &str,
+    ignore_case: bool,
+    usage: &str,
+    help_path: &str,
+) -> Result<Regex, CliExit> {
     RegexBuilder::new(pattern)
         .case_insensitive(ignore_case)
         .build()
-        .map_err(|e| usage_error(USAGE, HELP_PATH, &format!("invalid pattern: {e}")))
+        .map_err(|e| usage_error(usage, help_path, &format!("invalid pattern: {e}")))
+}
+
+/// An empty `--where` searches everywhere (cli.py's default).
+pub fn where_flags(wheres: &[String]) -> (bool, bool, bool) {
+    if wheres.is_empty() {
+        return (true, true, true);
+    }
+    (
+        wheres.iter().any(|w| w == "text"),
+        wheres.iter().any(|w| w == "thinking"),
+        wheres.iter().any(|w| w == "tools"),
+    )
+}
+
+/// `--max-matches 0` lifts the cap and so does leaving it off in corpus mode, where each
+/// match is one bounded window; anything else is a budget that must announce itself when
+/// it bites, so a whole-corpus sweep never looks complete at 20 rows.
+fn match_cap(max_matches: Option<usize>, default: Option<usize>) -> Option<usize> {
+    max_matches.map_or(default, |cap| (cap > 0).then_some(cap))
+}
+
+fn warn_truncated(cap: usize) {
+    eline(&format!(
+        "warning: stopped at --max-matches {cap}; more matches may exist — raise it, or pass --max-matches 0 for no cap"
+    ));
+}
+
+/// `grep --corpus`: one `corpus` window per line, matched verbatim. There is no event
+/// structure left to filter on, so only the pattern, `-i`, and `--max-matches` apply.
+fn run_over_corpus(args: &GrepArgs, corpus: &Path) -> Result<(), CliExit> {
+    let regex = compile_pattern(&args.pattern, args.ignore_case, USAGE, HELP_PATH)?;
+    let file =
+        File::open(corpus).map_err(|e| click_error(&format!("{}: {e}", corpus.display())))?;
+    let cap = match_cap(args.max_matches, None);
+    let mut out_lines: Vec<String> = Vec::new();
+    let mut truncated = false;
+    for line in BufReader::new(file).lines() {
+        let line = line.map_err(|e| click_error(&format!("{}: {e}", corpus.display())))?;
+        if !regex.is_match(&line) {
+            continue;
+        }
+        if cap.is_some_and(|cap| out_lines.len() == cap) {
+            truncated = true;
+            break;
+        }
+        out_lines.push(line);
+    }
+    let matched = out_lines.len();
+    out_lines.push(format!(
+        "{matched} matches in {}",
+        display_path(&corpus.to_string_lossy())
+    ));
+    let mut out = Out::new();
+    out.lines(out_lines)?;
+    out.finish()?;
+    if let Some(cap) = cap.filter(|_| truncated) {
+        warn_truncated(cap);
+    }
+    if matched == 0 {
+        return Err(CliExit(1));
+    }
+    Ok(())
 }
 
 fn fact_index(parsed: &Parsed) -> HashMap<String, ToolFact> {
@@ -159,16 +230,11 @@ fn fact_index(parsed: &Parsed) -> HashMap<String, ToolFact> {
 }
 
 pub fn run(args: GrepArgs) -> Result<(), CliExit> {
-    let regex = compile_pattern(&args.pattern, args.ignore_case)?;
-    let (w_text, w_thinking, w_tools) = if args.wheres.is_empty() {
-        (true, true, true)
-    } else {
-        (
-            args.wheres.iter().any(|w| w == "text"),
-            args.wheres.iter().any(|w| w == "thinking"),
-            args.wheres.iter().any(|w| w == "tools"),
-        )
-    };
+    if let Some(corpus) = &args.corpus {
+        return run_over_corpus(&args, corpus);
+    }
+    let regex = compile_pattern(&args.pattern, args.ignore_case, USAGE, HELP_PATH)?;
+    let (w_text, w_thinking, w_tools) = where_flags(&args.wheres);
     let paths: Vec<PathBuf> = args
         .paths
         .iter()
@@ -186,9 +252,11 @@ pub fn run(args: GrepArgs) -> Result<(), CliExit> {
     let mut out_lines: Vec<String> = Vec::new();
     let mut files_matched = 0usize;
     let mut matched = 0usize;
-    let mut budget = args.max_matches;
+    let cap = match_cap(args.max_matches, Some(DEFAULT_MAX_MATCHES));
+    let mut truncated = false;
     for parsed in parse_transcripts(&targets.paths) {
-        if budget == 0 {
+        if cap.is_some_and(|cap| matched == cap) {
+            truncated = true;
             break;
         }
         let names = tool_names(&parsed.entries);
@@ -197,7 +265,7 @@ pub fn run(args: GrepArgs) -> Result<(), CliExit> {
         } else {
             HashMap::new()
         };
-        let hits: Vec<usize> = parsed
+        let mut hits: Vec<usize> = parsed
             .entries
             .iter()
             .enumerate()
@@ -219,14 +287,18 @@ pub fn run(args: GrepArgs) -> Result<(), CliExit> {
                 }
             })
             .map(|(index, _)| index)
-            .take(budget)
             .collect();
+        if let Some(cap) = cap {
+            if matched + hits.len() > cap {
+                truncated = true;
+                hits.truncate(cap - matched);
+            }
+        }
         if hits.is_empty() {
             continue;
         }
         files_matched += 1;
         matched += hits.len();
-        budget -= hits.len();
         let windows = merge_windows(&hits, args.context, parsed.entries.len());
         if args.json {
             let hit_set: std::collections::HashSet<usize> = hits.iter().copied().collect();
@@ -284,6 +356,9 @@ pub fn run(args: GrepArgs) -> Result<(), CliExit> {
     let mut out = Out::new();
     out.lines(out_lines)?;
     out.finish()?;
+    if let Some(cap) = cap.filter(|_| truncated) {
+        warn_truncated(cap);
+    }
     if matched == 0 {
         return Err(CliExit(1));
     }

{cc_transcript-14.23.0 → cc_transcript-14.25.0}/rust/crates/cli/src/commands/mod.rs

@@ -1,4 +1,5 @@
 pub mod blame;
+pub mod corpus;
 pub mod corrections;
 pub mod digest;
 pub mod facts;

{cc_transcript-14.23.0 → cc_transcript-14.25.0}/rust/crates/cli/src/lib.rs

@@ -44,6 +44,27 @@ fn pkg_version() -> String {
 const KIND_CHOICES: [&str; 6] = ["user", "assistant", "system", "mode", "other", "attachment"];
 const WHERE_CHOICES: [&str; 3] = ["text", "thinking", "tools"];
 const LIST_PROVIDER_CHOICES: [&str; 3] = ["claude", "codex", "all"];
+const DEFAULT_LIMIT: usize = 50;
+
+/// `grep --corpus` reads a flattened extract, so every flag that selects transcripts or
+/// reaches into an event's structure is rejected rather than silently ignored.
+const CORPUS_INCOMPATIBLE: [&str; 15] = [
+    "paths",
+    "root",
+    "project",
+    "contains",
+    "limit",
+    "all",
+    "kinds",
+    "tool",
+    "errors",
+    "wheres",
+    "context",
+    "width",
+    "uuids",
+    "with_result",
+    "json",
+];
 
 #[derive(Parser)]
 #[command(
@@ -68,9 +89,9 @@ pub struct DiscoveryOpts {
     /// Substring filter over transcript file names.
     #[arg(long)]
     pub contains: Option<String>,
-    /// Keep only the newest N transcripts.
-    #[arg(long, default_value_t = 50)]
-    pub limit: usize,
+    /// Keep only the newest N transcripts [default: 50, uncapped for corpus].
+    #[arg(long)]
+    pub limit: Option<usize>,
     /// Ignore --limit.
     #[arg(long)]
     pub all: bool,
@@ -93,7 +114,17 @@ impl DiscoveryOpts {
         if self.all {
             None
         } else {
-            Some(self.limit)
+            Some(self.limit.unwrap_or(DEFAULT_LIMIT))
+        }
+    }
+
+    /// A whole-corpus sweep's limit: unbounded unless `--limit` asks for a cap, so an
+    /// extract never silently covers only the newest 50 transcripts.
+    pub fn sweep_limit(&self) -> Option<usize> {
+        if self.all {
+            None
+        } else {
+            self.limit
         }
     }
 }
@@ -166,6 +197,10 @@ pub enum Cmd {
         paths: Vec<PathBuf>,
         #[command(flatten)]
         discovery: DiscoveryOpts,
+        /// Search a `corpus` extract instead of transcripts: its windows carry no event
+        /// structure, so discovery, kind, tool, context, and rendering flags do not apply.
+        #[arg(long, conflicts_with_all = CORPUS_INCOMPATIBLE)]
+        corpus: Option<PathBuf>,
         /// Keep only these event kinds.
         #[arg(long = "kind", value_parser = KIND_CHOICES)]
         kinds: Vec<String>,
@@ -184,9 +219,9 @@ pub enum Cmd {
         /// Events of context around each hit.
         #[arg(short = 'C', long, default_value_t = 0)]
         context: usize,
-        /// Stop after this many matches.
-        #[arg(long = "max-matches", default_value_t = 20)]
-        max_matches: usize,
+        /// Stop after this many matches; 0 lifts the cap [default: 20, uncapped with --corpus].
+        #[arg(long = "max-matches")]
+        max_matches: Option<usize>,
         /// Truncation width per chunk (0 = no cut).
         #[arg(long, default_value_t = 100)]
         width: usize,
@@ -200,6 +235,25 @@ pub enum Cmd {
         #[arg(long)]
         json: bool,
     },
+    /// Sweep the matched transcripts into a deduped file of character windows around every hit.
+    Corpus {
+        pattern: String,
+        paths: Vec<PathBuf>,
+        #[command(flatten)]
+        discovery: DiscoveryOpts,
+        /// Search only these areas [default: all].
+        #[arg(long = "where", value_parser = WHERE_CHOICES)]
+        wheres: Vec<String>,
+        /// Case-insensitive matching.
+        #[arg(short = 'i', long = "ignore-case")]
+        ignore_case: bool,
+        /// Characters kept either side of each match.
+        #[arg(long, default_value_t = 200)]
+        window: usize,
+        /// Write the extract here, one window per line.
+        #[arg(short = 'o', long, required = true)]
+        out: PathBuf,
+    },
     /// Summarize event, model, and tool statistics.
     Stats {
         paths: Vec<PathBuf>,
@@ -493,6 +547,7 @@ fn dispatch(cmd: Cmd) -> Result<(), CliExit> {
             pattern,
             paths,
             discovery,
+            corpus,
             kinds,
             tool,
             errors,
@@ -508,6 +563,7 @@ fn dispatch(cmd: Cmd) -> Result<(), CliExit> {
             pattern,
             paths,
             discovery,
+            corpus,
             kinds,
             tool,
             errors,
@@ -520,6 +576,23 @@ fn dispatch(cmd: Cmd) -> Result<(), CliExit> {
             with_result,
             json,
         }),
+        Cmd::Corpus {
+            pattern,
+            paths,
+            discovery,
+            wheres,
+            ignore_case,
+            window,
+            out,
+        } => commands::corpus::run(commands::corpus::CorpusArgs {
+            pattern,
+            paths,
+            discovery,
+            wheres,
+            ignore_case,
+            window,
+            out,
+        }),
         Cmd::Stats {
             paths,
             discovery,