@stupify/cli 0.0.5 → 0.0.7

package/dist/cache.js

@@ -10,11 +10,9 @@ export async function cachedJson(namespace, key, compute) {
     const filePath = cachePath(namespace, key);
     try {
         const value = JSON.parse(await readFile(filePath, "utf8"));
-        console.error(`cache hit ${namespace} ${key.slice(0, 12)}`);
         return value;
     }
     catch {
-        console.error(`cache miss ${namespace} ${key.slice(0, 12)}`);
     }
     const value = await compute();
     await writeCache(filePath, value).catch(() => undefined);

package/dist/checks.js

@@ -173,7 +173,7 @@ Prefer no match over a weak match.`,
             "helper is domain-specific or used by multiple local call sites",
         ],
         hookMode: "warn",
-        searchPrompt: "Find only tiny generic utility functions that recreate common helpers such as clamp, debounce, throttle, slugify, group, sort, pick, omit, uniq, or shuffle without domain-specific behavior. Do not match resolve/parse/format helpers, domain formatting, feature constants, or helpers with multiple obvious call sites.",
+        searchPrompt: "Find only tiny generic utility functions that recreate common helpers such as clamp, debounce, throttle, slugify, sort, pick, omit, uniq, or shuffle without domain-specific behavior. Do not match group/resolve/parse/format helpers, domain formatting, feature constants, or helpers with multiple obvious call sites.",
         searchExamples: {
             match: [
                 "clampValue returns min, max, or value.",

package/dist/constants.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "0.0.5";
+export declare const VERSION = "0.0.7";
 import type { ModelConfig, ModelId } from "./types.ts";
 export declare const DEFAULT_MODEL_ID: ModelId;
 export declare const MODEL_REGISTRY: Record<ModelId, ModelConfig>;

package/dist/constants.js

@@ -1,4 +1,4 @@
-export const VERSION = "0.0.5";
+export const VERSION = "0.0.7";
 export const DEFAULT_MODEL_ID = "gemma-4-e2b";
 export const MODEL_REGISTRY = {
     "gemma-4-e2b": {

package/dist/counter-scout.js

@@ -120,7 +120,7 @@ function lintBypassSignal(value) {
 }
 function reinventedUtilitySignal(change) {
     const name = change.entityName;
-    if (!/^(clamp|debounce|throttle|slug|slugify|group|sort|shuffle|memoize|pick|omit|uniq)/i.test(name))
+    if (!/^(clamp|debounce|throttle|slug|slugify|sort|shuffle|memoize|pick|omit|uniq)/i.test(name))
         return false;
     const content = change.afterContent ?? "";
     if (/currency|invoice|refund|subscription|tier|domain/i.test(`${name}\n${content}`))

package/dist/model.js

@@ -36,7 +36,7 @@ export async function loadLocalModel(modelPath, modelId, profile = "scout") {
         if (runningModel !== modelId)
             await stopManagedServer(runtime);
         if (runningModel === modelId) {
-            console.error(`Using already-loaded local ${profile} model: ${selectedModel.name}`);
+            console.error(`Using local model: ${selectedModel.name}`);
             return {
                 id: modelId,
                 name: selectedModel.name,
@@ -107,7 +107,7 @@ async function startLlamaServer(modelPath, modelId, modelName, runtime) {
     const logPath = path.join(logDir, "llama-server.log");
     const out = await open(logPath, "a");
     const err = await open(logPath, "a");
-    console.error(`Starting local ${runtime.profile} model server: ${modelName}`);
+    console.error(`Starting local model server: ${modelName}`);
     console.error(`llama-server log: ${logPath}`);
     const args = [
         "-m",
@@ -158,7 +158,7 @@ async function stopManagedServer(runtime) {
         throw new Error(`A llama-server is already running with ${runningModel ?? "another model"}.
 Stop it before switching models, or use STUPIFY_LLAMA_SERVER_URL for that server.`);
     }
-    console.error(`Restarting local ${runtime.profile} model server for selected model.`);
+    console.error("Restarting local model server for selected model.");
     try {
         process.kill(pid, "SIGTERM");
     }

package/dist/render.js

@@ -12,7 +12,7 @@ ${run.stats.inputTokenCap ?? "unknown"} tokens
 Stupify skipped the search rather than review truncated context.
 Nothing was blocked.
 Try:
-stupify ${sourceHint(command)} --max-search-input-tokens ${Math.max((run.stats.inputTokens ?? 12_000) + 1, (run.stats.inputTokenCap ?? 12_000) * 2)}`;
+rerun with ${sourceHint(command)} --max-search-input-tokens ${Math.max((run.stats.inputTokens ?? 12_000) + 1, (run.stats.inputTokenCap ?? 12_000) * 2)}`;
     }
     if (run.stats.skipped && run.stats.skipReason === "no_candidates") {
         return `🧙 stupify 🪄

package/dist/stupify.js

@@ -48,12 +48,9 @@ export async function runSearchCommand(command, startedAt) {
     const t = createTracer({
         writeLine: () => undefined,
         onEvent: (event) => {
-            const parts = [`trace ${event.name}`, `${event.ms}ms`];
-            if (event.count !== undefined)
-                parts.push(`count=${event.count}`);
-            if (event.detail)
-                parts.push(event.detail);
-            console.error(parts.join(" "));
+            if (command.json)
+                return;
+            console.error(formatStep(event.name, event.ms, event.count, event.detail));
         },
     });
     const profile = await loadSearchProfile(command.searchProfilePath);
@@ -61,12 +58,12 @@ export async function runSearchCommand(command, startedAt) {
     const patternIds = checks.map((check) => check.id);
     const maxCandidates = effectiveMaxCandidates(command.maxCandidates, profile);
     const maxSearchInputTokens = effectiveMaxSearchInputTokens(command.maxSearchInputTokens, profile);
+    printRunPlan(command, patternIds);
     const { value: changeSet } = await t.trace("entity.diff", () => semChangeSetForCommand(command), {
         count: (v) => v.summary.total,
         detail: (v) => `${v.summary.fileCount} files`,
     });
     try {
-        printRunPlan(command, changeSet.summary.fileCount, changeSet.summary.total, patternIds);
         const candidates = counterScoutTargets(changeSet, checks, maxCandidates);
         const contexts = entityContextsFromChanges(candidates, changeSet.changes);
         const targetsByPattern = countTargetsByPattern(contexts);
@@ -136,11 +133,18 @@ export async function runSearchCommand(command, startedAt) {
         const pack = profile?.context === "sem" || searchContexts.length === contexts.length
             ? initialPack
             : await repomixContextPack(changeSet.contextCwd, searchContexts, changeSet.changes, baseRepomixConfig);
-        const modelPath = await firstRunModelBootstrap(command.model);
-        const model = await loadLocalModel(modelPath, command.model, "scout");
-        const request = buildSearchRequest(changeSet, searchContexts, pack, checks, profile, command.includeCounterReasonInPrompt);
-        const inputTokens = await countPromptTokens(model, request.prompt);
-        if (inputTokens > maxSearchInputTokens) {
+        const batches = await buildSearchBatches({
+            command,
+            changeSet,
+            contexts: searchContexts,
+            initialPack: pack,
+            checks,
+            profile,
+            includeCounterReasonInPrompt: command.includeCounterReasonInPrompt,
+            maxSearchInputTokens,
+            baseRepomixConfig,
+        });
+        if (batches.batches.length === 0) {
             return {
                 schemaVersion: "search.v1",
                 mode: "search",
@@ -150,7 +154,7 @@ export async function runSearchCommand(command, startedAt) {
                 stats: {
                     elapsedMs: Date.now() - startedAt,
                     modelCalls: 0,
-                    inputTokens,
+                    inputTokens: batches.estimatedInputTokens,
                     inputTokenCap: maxSearchInputTokens,
                     skipped: true,
                     skipReason: "input_too_large",
@@ -161,6 +165,8 @@ export async function runSearchCommand(command, startedAt) {
                     repomixFiles: pack.filePaths.length,
                     repomixTokens: pack.totalTokens,
                     repomixConfig: pack.config,
+                    searchBatches: 0,
+                    skippedTargets: batches.skippedTargets,
                     profileId: profile?.id,
                     targetsByPattern: countTargetsByPattern(searchContexts),
                     targetsPreview: previewTargets(searchContexts),
@@ -168,7 +174,33 @@ export async function runSearchCommand(command, startedAt) {
                 matches: [],
             };
         }
-        const { value: matches } = await t.trace("search.model", () => runSearch(model, request), { count: (v) => v.length });
+        if (batches.wasSplit && !command.json) {
+            console.error(`Search input is large; queued ${batches.batches.length} smaller search batches.`);
+            if (batches.skippedTargets > 0) {
+                console.error(`Skipped ${batches.skippedTargets} oversized targets that could not fit alone.`);
+            }
+        }
+        const modelPath = await firstRunModelBootstrap(command.model);
+        const model = await loadLocalModel(modelPath, command.model, "scout");
+        const matches = [];
+        let modelCalls = 0;
+        let inputTokens = 0;
+        let exactSkippedTargets = batches.skippedTargets;
+        for (const batch of batches.batches) {
+            const batchInputTokens = await countPromptTokens(model, batch.request.prompt);
+            inputTokens += batchInputTokens;
+            if (batchInputTokens > maxSearchInputTokens) {
+                exactSkippedTargets += batch.contexts.length;
+                if (!command.json) {
+                    console.error(`Skipped ${batch.contexts.length} targets after exact token count exceeded the limit.`);
+                }
+                continue;
+            }
+            const { value } = await t.trace("search.model", () => runSearch(model, batch.request), { count: (v) => v.length });
+            modelCalls += 1;
+            matches.push(...value);
+        }
+        const uniqueMatches = dedupeMatches(matches);
         return {
             schemaVersion: "search.v1",
             mode: "search",
@@ -177,7 +209,7 @@ export async function runSearchCommand(command, startedAt) {
             patterns: patternIds,
             stats: {
                 elapsedMs: Date.now() - startedAt,
-                modelCalls: 1,
+                modelCalls,
                 inputTokens,
                 inputTokenCap: maxSearchInputTokens,
                 filesChanged: changeSet.summary.fileCount,
@@ -187,17 +219,91 @@ export async function runSearchCommand(command, startedAt) {
                 repomixFiles: pack.filePaths.length,
                 repomixTokens: pack.totalTokens,
                 repomixConfig: pack.config,
+                searchBatches: batches.batches.length,
+                skippedTargets: exactSkippedTargets,
                 profileId: profile?.id,
                 targetsByPattern: countTargetsByPattern(searchContexts),
                 targetsPreview: previewTargets(searchContexts),
             },
-            matches,
+            matches: uniqueMatches,
         };
     }
     finally {
         await changeSet.cleanup();
     }
 }
+function dedupeMatches(matches) {
+    const seen = new Set();
+    return matches.filter((match) => {
+        const key = `${match.patternId}\n${match.proof.trim()}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+async function buildSearchBatches(input) {
+    const first = makeSearchBatch(input, input.contexts, input.initialPack);
+    if (first.estimatedInputTokens <= input.maxSearchInputTokens) {
+        return {
+            batches: [first],
+            estimatedInputTokens: first.estimatedInputTokens,
+            skippedTargets: 0,
+            wasSplit: false,
+        };
+    }
+    const batches = [];
+    let skippedTargets = 0;
+    let currentContexts = [];
+    let currentBatch = null;
+    for (const context of input.contexts) {
+        const candidateContexts = [...currentContexts, context];
+        const candidateBatch = await makeSearchBatchWithPack(input, candidateContexts);
+        if (candidateBatch.estimatedInputTokens <= input.maxSearchInputTokens) {
+            currentContexts = candidateContexts;
+            currentBatch = candidateBatch;
+            continue;
+        }
+        if (currentBatch) {
+            batches.push(currentBatch);
+            currentContexts = [];
+            currentBatch = null;
+        }
+        const singleBatch = candidateContexts.length === 1
+            ? candidateBatch
+            : await makeSearchBatchWithPack(input, [context]);
+        if (singleBatch.estimatedInputTokens <= input.maxSearchInputTokens) {
+            currentContexts = [context];
+            currentBatch = singleBatch;
+        }
+        else {
+            skippedTargets += 1;
+        }
+    }
+    if (currentBatch)
+        batches.push(currentBatch);
+    return {
+        batches,
+        estimatedInputTokens: first.estimatedInputTokens,
+        skippedTargets,
+        wasSplit: true,
+    };
+}
+function makeSearchBatch(input, contexts, pack) {
+    const request = buildSearchRequest(input.changeSet, contexts, pack, input.checks, input.profile, input.includeCounterReasonInPrompt);
+    return {
+        contexts,
+        pack,
+        request,
+        estimatedInputTokens: estimatePromptTokens(request.prompt),
+    };
+}
+async function makeSearchBatchWithPack(input, contexts) {
+    const pack = input.profile?.context === "sem"
+        ? emptyContextPack()
+        : await repomixContextPack(input.changeSet.contextCwd, contexts, input.changeSet.changes, input.baseRepomixConfig);
+    return makeSearchBatch(input, contexts, pack);
+}
 function buildSearchRequest(changeSet, contexts, pack, patterns, profile, includeCounterReasonInPrompt) {
     return searchRequest({
         changeSet,
@@ -207,14 +313,36 @@ function buildSearchRequest(changeSet, contexts, pack, patterns, profile, includ
         includeCounterReasonInPrompt: profile?.includeCounterReasonInPrompt ?? includeCounterReasonInPrompt,
     });
 }
-function printRunPlan(command, filesChanged, entitiesScanned, patternIds) {
+function printRunPlan(command, patternIds) {
     if (command.json)
         return;
     console.error("🧙 stupify 🪄");
-    console.error(`Mode: search (${command.source})`);
-    console.error(`Sem: ${filesChanged} files, ${entitiesScanned} changed entities`);
+    console.error(`Search: ${sourceLabel(command)}`);
     console.error(`Patterns: ${patternIds.join(", ")}`);
 }
+function formatStep(name, ms, count, detail) {
+    if (name === "entity.diff")
+        return `Diff: ${detail ?? "changed files"}, ${count ?? 0} changed entities (${ms}ms)`;
+    if (name === "context.pack")
+        return `Context: ${count ?? 0} files, ${detail ?? "0 tokens"} (${ms}ms)`;
+    if (name === "search.model")
+        return `Model: ${count ?? 0} matches (${ms}ms)`;
+    return `${name}: ${ms}ms`;
+}
+function sourceLabel(command) {
+    if (command.kind === "since")
+        return `since ${command.since}`;
+    if (command.kind === "commit")
+        return `commit ${command.commit}`;
+    if (command.kind === "commits")
+        return `last ${command.count} commits`;
+    if (command.kind === "staged")
+        return "staged changes";
+    return "stdin diff";
+}
+function estimatePromptTokens(prompt) {
+    return Math.ceil(prompt.length / 3);
+}
 function countTargetsByPattern(contexts) {
     const counts = {};
     for (const context of contexts)

package/dist/types.d.ts

@@ -219,6 +219,8 @@ export type SearchRunJson = Readonly<{
         repomixTokens?: number;
         repomixConfig?: RepomixSearchConfig;
         searchTargets?: number;
+        searchBatches?: number;
+        skippedTargets?: number;
         profileId?: string;
         targetsByPattern?: Readonly<Record<string, number>>;
         targetsPreview?: readonly SearchTargetPreview[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stupify/cli",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Local-only diagnostic CLI for checking whether AI is making you dumber.",
   "private": false,
   "type": "module",

package/src/cache.ts

@@ -16,10 +16,8 @@ export async function cachedJson<T>(
   const filePath = cachePath(namespace, key);
   try {
     const value = JSON.parse(await readFile(filePath, "utf8")) as T;
-    console.error(`cache hit ${namespace} ${key.slice(0, 12)}`);
     return value;
   } catch {
-    console.error(`cache miss ${namespace} ${key.slice(0, 12)}`);
   }
 
   const value = await compute();

package/src/checks.ts

@@ -174,7 +174,7 @@ Prefer no match over a weak match.`,
       "helper is domain-specific or used by multiple local call sites",
     ],
     hookMode: "warn",
-    searchPrompt: "Find only tiny generic utility functions that recreate common helpers such as clamp, debounce, throttle, slugify, group, sort, pick, omit, uniq, or shuffle without domain-specific behavior. Do not match resolve/parse/format helpers, domain formatting, feature constants, or helpers with multiple obvious call sites.",
+    searchPrompt: "Find only tiny generic utility functions that recreate common helpers such as clamp, debounce, throttle, slugify, sort, pick, omit, uniq, or shuffle without domain-specific behavior. Do not match group/resolve/parse/format helpers, domain formatting, feature constants, or helpers with multiple obvious call sites.",
     searchExamples: {
       match: [
         "clampValue returns min, max, or value.",

package/src/constants.ts

@@ -1,4 +1,4 @@
-export const VERSION = "0.0.5";
+export const VERSION = "0.0.7";
 import type { ModelConfig, ModelId } from "./types.ts";
 
 export const DEFAULT_MODEL_ID: ModelId = "gemma-4-e2b";

package/src/counter-scout.ts

@@ -140,7 +140,7 @@ function lintBypassSignal(value: string): boolean {
 
 function reinventedUtilitySignal(change: SemChange): boolean {
   const name = change.entityName;
-  if (!/^(clamp|debounce|throttle|slug|slugify|group|sort|shuffle|memoize|pick|omit|uniq)/i.test(name)) return false;
+  if (!/^(clamp|debounce|throttle|slug|slugify|sort|shuffle|memoize|pick|omit|uniq)/i.test(name)) return false;
   const content = change.afterContent ?? "";
   if (/currency|invoice|refund|subscription|tier|domain/i.test(`${name}\n${content}`)) return false;
   return true;

package/src/model.ts

@@ -85,7 +85,7 @@ export async function loadLocalModel(
     if (runningModel !== modelId) await stopManagedServer(runtime);
     if (runningModel === modelId) {
       console.error(
-        `Using already-loaded local ${profile} model: ${selectedModel.name}`,
+        `Using local model: ${selectedModel.name}`,
       );
       return {
         id: modelId,
@@ -166,7 +166,7 @@ async function startLlamaServer(
   const out = await open(logPath, "a");
   const err = await open(logPath, "a");
 
-  console.error(`Starting local ${runtime.profile} model server: ${modelName}`);
+  console.error(`Starting local model server: ${modelName}`);
   console.error(`llama-server log: ${logPath}`);
 
   const args = [
@@ -215,7 +215,7 @@ Stop it before switching models, or use STUPIFY_LLAMA_SERVER_URL for that server
   }
 
   console.error(
-    `Restarting local ${runtime.profile} model server for selected model.`,
+    "Restarting local model server for selected model.",
   );
   try {
     process.kill(pid, "SIGTERM");

package/src/render.ts

@@ -14,7 +14,7 @@ ${run.stats.inputTokenCap ?? "unknown"} tokens
 Stupify skipped the search rather than review truncated context.
 Nothing was blocked.
 Try:
-stupify ${sourceHint(command)} --max-search-input-tokens ${Math.max((run.stats.inputTokens ?? 12_000) + 1, (run.stats.inputTokenCap ?? 12_000) * 2)}`;
+rerun with ${sourceHint(command)} --max-search-input-tokens ${Math.max((run.stats.inputTokens ?? 12_000) + 1, (run.stats.inputTokenCap ?? 12_000) * 2)}`;
   }
 
   if (run.stats.skipped && run.stats.skipReason === "no_candidates") {

package/src/stupify.ts

@@ -2,7 +2,7 @@
 
 import { realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { countPromptTokens, runSearch, searchRequest } from "./analysis.ts";
+import { countPromptTokens, runSearch, searchRequest, type SearchRequest } from "./analysis.ts";
 import { searchChecks } from "./checks.ts";
 import { parseCommand } from "./command.ts";
 import { counterScoutTargets } from "./counter-scout.ts";
@@ -58,10 +58,8 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
   const t = createTracer({
     writeLine: () => undefined,
     onEvent: (event) => {
-      const parts = [`trace ${event.name}`, `${event.ms}ms`];
-      if (event.count !== undefined) parts.push(`count=${event.count}`);
-      if (event.detail) parts.push(event.detail);
-      console.error(parts.join(" "));
+      if (command.json) return;
+      console.error(formatStep(event.name, event.ms, event.count, event.detail));
     },
   });
 
@@ -70,6 +68,7 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
   const patternIds = checks.map((check) => check.id);
   const maxCandidates = effectiveMaxCandidates(command.maxCandidates, profile);
   const maxSearchInputTokens = effectiveMaxSearchInputTokens(command.maxSearchInputTokens, profile);
+  printRunPlan(command, patternIds);
   const { value: changeSet } = await t.trace(
     "entity.diff",
     () => semChangeSetForCommand(command),
@@ -80,7 +79,6 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
   );
 
   try {
-    printRunPlan(command, changeSet.summary.fileCount, changeSet.summary.total, patternIds);
     const candidates = counterScoutTargets(changeSet, checks, maxCandidates);
     const contexts = entityContextsFromChanges(candidates, changeSet.changes);
     const targetsByPattern = countTargetsByPattern(contexts);
@@ -155,19 +153,19 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
     const pack = profile?.context === "sem" || searchContexts.length === contexts.length
       ? initialPack
       : await repomixContextPack(changeSet.contextCwd, searchContexts, changeSet.changes, baseRepomixConfig);
-
-    const modelPath = await firstRunModelBootstrap(command.model);
-    const model = await loadLocalModel(modelPath, command.model, "scout");
-    const request = buildSearchRequest(
+    const batches = await buildSearchBatches({
+      command,
       changeSet,
-      searchContexts,
-      pack,
+      contexts: searchContexts,
+      initialPack: pack,
       checks,
       profile,
-      command.includeCounterReasonInPrompt,
-    );
-    const inputTokens = await countPromptTokens(model, request.prompt);
-    if (inputTokens > maxSearchInputTokens) {
+      includeCounterReasonInPrompt: command.includeCounterReasonInPrompt,
+      maxSearchInputTokens,
+      baseRepomixConfig,
+    });
+
+    if (batches.batches.length === 0) {
       return {
         schemaVersion: "search.v1",
         mode: "search",
@@ -177,7 +175,7 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
         stats: {
           elapsedMs: Date.now() - startedAt,
           modelCalls: 0,
-          inputTokens,
+          inputTokens: batches.estimatedInputTokens,
           inputTokenCap: maxSearchInputTokens,
           skipped: true,
           skipReason: "input_too_large",
@@ -188,6 +186,8 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
           repomixFiles: pack.filePaths.length,
           repomixTokens: pack.totalTokens,
           repomixConfig: pack.config,
+          searchBatches: 0,
+          skippedTargets: batches.skippedTargets,
           profileId: profile?.id,
           targetsByPattern: countTargetsByPattern(searchContexts),
           targetsPreview: previewTargets(searchContexts),
@@ -196,11 +196,38 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
       };
     }
 
-    const { value: matches } = await t.trace(
-      "search.model",
-      () => runSearch(model, request),
-      { count: (v) => v.length },
-    );
+    if (batches.wasSplit && !command.json) {
+      console.error(`Search input is large; queued ${batches.batches.length} smaller search batches.`);
+      if (batches.skippedTargets > 0) {
+        console.error(`Skipped ${batches.skippedTargets} oversized targets that could not fit alone.`);
+      }
+    }
+
+    const modelPath = await firstRunModelBootstrap(command.model);
+    const model = await loadLocalModel(modelPath, command.model, "scout");
+    const matches = [];
+    let modelCalls = 0;
+    let inputTokens = 0;
+    let exactSkippedTargets = batches.skippedTargets;
+    for (const batch of batches.batches) {
+      const batchInputTokens = await countPromptTokens(model, batch.request.prompt);
+      inputTokens += batchInputTokens;
+      if (batchInputTokens > maxSearchInputTokens) {
+        exactSkippedTargets += batch.contexts.length;
+        if (!command.json) {
+          console.error(`Skipped ${batch.contexts.length} targets after exact token count exceeded the limit.`);
+        }
+        continue;
+      }
+      const { value } = await t.trace(
+        "search.model",
+        () => runSearch(model, batch.request),
+        { count: (v) => v.length },
+      );
+      modelCalls += 1;
+      matches.push(...value);
+    }
+    const uniqueMatches = dedupeMatches(matches);
 
     return {
       schemaVersion: "search.v1",
@@ -210,7 +237,7 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
       patterns: patternIds,
       stats: {
         elapsedMs: Date.now() - startedAt,
-        modelCalls: 1,
+        modelCalls,
         inputTokens,
         inputTokenCap: maxSearchInputTokens,
         filesChanged: changeSet.summary.fileCount,
@@ -220,17 +247,146 @@ export async function runSearchCommand(command: SearchCommand, startedAt: number
         repomixFiles: pack.filePaths.length,
         repomixTokens: pack.totalTokens,
         repomixConfig: pack.config,
+        searchBatches: batches.batches.length,
+        skippedTargets: exactSkippedTargets,
         profileId: profile?.id,
         targetsByPattern: countTargetsByPattern(searchContexts),
         targetsPreview: previewTargets(searchContexts),
       },
-      matches,
+      matches: uniqueMatches,
     };
   } finally {
     await changeSet.cleanup();
   }
 }
 
+function dedupeMatches<T extends { targetId: string; patternId: string; proof: string }>(matches: readonly T[]): readonly T[] {
+  const seen = new Set<string>();
+  return matches.filter((match) => {
+    const key = `${match.patternId}\n${match.proof.trim()}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+type SearchBatch = Readonly<{
+  contexts: readonly SemContext[];
+  pack: SemContextPack;
+  request: SearchRequest;
+  estimatedInputTokens: number;
+}>;
+
+async function buildSearchBatches(input: Readonly<{
+  command: SearchCommand;
+  changeSet: Parameters<typeof searchRequest>[0]["changeSet"];
+  contexts: readonly SemContext[];
+  initialPack: SemContextPack;
+  checks: readonly StupifyCheck[];
+  profile: SearchProfile | null;
+  includeCounterReasonInPrompt: boolean;
+  maxSearchInputTokens: number;
+  baseRepomixConfig: Parameters<typeof repomixContextPack>[3];
+}>): Promise<Readonly<{
+  batches: readonly SearchBatch[];
+  estimatedInputTokens: number;
+  skippedTargets: number;
+  wasSplit: boolean;
+}>> {
+  const first = makeSearchBatch(input, input.contexts, input.initialPack);
+  if (first.estimatedInputTokens <= input.maxSearchInputTokens) {
+    return {
+      batches: [first],
+      estimatedInputTokens: first.estimatedInputTokens,
+      skippedTargets: 0,
+      wasSplit: false,
+    };
+  }
+
+  const batches: SearchBatch[] = [];
+  let skippedTargets = 0;
+  let currentContexts: readonly SemContext[] = [];
+  let currentBatch: SearchBatch | null = null;
+
+  for (const context of input.contexts) {
+    const candidateContexts = [...currentContexts, context];
+    const candidateBatch = await makeSearchBatchWithPack(input, candidateContexts);
+    if (candidateBatch.estimatedInputTokens <= input.maxSearchInputTokens) {
+      currentContexts = candidateContexts;
+      currentBatch = candidateBatch;
+      continue;
+    }
+
+    if (currentBatch) {
+      batches.push(currentBatch);
+      currentContexts = [];
+      currentBatch = null;
+    }
+
+    const singleBatch = candidateContexts.length === 1
+      ? candidateBatch
+      : await makeSearchBatchWithPack(input, [context]);
+    if (singleBatch.estimatedInputTokens <= input.maxSearchInputTokens) {
+      currentContexts = [context];
+      currentBatch = singleBatch;
+    } else {
+      skippedTargets += 1;
+    }
+  }
+
+  if (currentBatch) batches.push(currentBatch);
+
+  return {
+    batches,
+    estimatedInputTokens: first.estimatedInputTokens,
+    skippedTargets,
+    wasSplit: true,
+  };
+}
+
+function makeSearchBatch(
+  input: Readonly<{
+    changeSet: Parameters<typeof searchRequest>[0]["changeSet"];
+    checks: readonly StupifyCheck[];
+    profile: SearchProfile | null;
+    includeCounterReasonInPrompt: boolean;
+  }>,
+  contexts: readonly SemContext[],
+  pack: SemContextPack,
+): SearchBatch {
+  const request = buildSearchRequest(
+    input.changeSet,
+    contexts,
+    pack,
+    input.checks,
+    input.profile,
+    input.includeCounterReasonInPrompt,
+  );
+  return {
+    contexts,
+    pack,
+    request,
+    estimatedInputTokens: estimatePromptTokens(request.prompt),
+  };
+}
+
+async function makeSearchBatchWithPack(
+  input: Readonly<{
+    command: SearchCommand;
+    changeSet: Parameters<typeof searchRequest>[0]["changeSet"];
+    checks: readonly StupifyCheck[];
+    profile: SearchProfile | null;
+    includeCounterReasonInPrompt: boolean;
+    baseRepomixConfig: Parameters<typeof repomixContextPack>[3];
+  }>,
+  contexts: readonly SemContext[],
+): Promise<SearchBatch> {
+  const pack = input.profile?.context === "sem"
+    ? emptyContextPack()
+    : await repomixContextPack(input.changeSet.contextCwd, contexts, input.changeSet.changes, input.baseRepomixConfig);
+  return makeSearchBatch(input, contexts, pack);
+}
+
 function buildSearchRequest(
   changeSet: Parameters<typeof searchRequest>[0]["changeSet"],
   contexts: Parameters<typeof searchRequest>[0]["contexts"],
@@ -250,17 +406,33 @@ function buildSearchRequest(
 
 function printRunPlan(
   command: SearchCommand,
-  filesChanged: number,
-  entitiesScanned: number,
   patternIds: readonly string[],
 ): void {
   if (command.json) return;
   console.error("🧙 stupify 🪄");
-  console.error(`Mode: search (${command.source})`);
-  console.error(`Sem: ${filesChanged} files, ${entitiesScanned} changed entities`);
+  console.error(`Search: ${sourceLabel(command)}`);
   console.error(`Patterns: ${patternIds.join(", ")}`);
 }
 
+function formatStep(name: string, ms: number, count?: number, detail?: string): string {
+  if (name === "entity.diff") return `Diff: ${detail ?? "changed files"}, ${count ?? 0} changed entities (${ms}ms)`;
+  if (name === "context.pack") return `Context: ${count ?? 0} files, ${detail ?? "0 tokens"} (${ms}ms)`;
+  if (name === "search.model") return `Model: ${count ?? 0} matches (${ms}ms)`;
+  return `${name}: ${ms}ms`;
+}
+
+function sourceLabel(command: SearchCommand): string {
+  if (command.kind === "since") return `since ${command.since}`;
+  if (command.kind === "commit") return `commit ${command.commit}`;
+  if (command.kind === "commits") return `last ${command.count} commits`;
+  if (command.kind === "staged") return "staged changes";
+  return "stdin diff";
+}
+
+function estimatePromptTokens(prompt: string): number {
+  return Math.ceil(prompt.length / 3);
+}
+
 function countTargetsByPattern(contexts: readonly SemContext[]): Record<string, number> {
   const counts: Record<string, number> = {};
   for (const context of contexts) counts[context.checkId] = (counts[context.checkId] ?? 0) + 1;

package/src/types.ts

@@ -216,6 +216,8 @@ export type SearchRunJson = Readonly<{
     repomixTokens?: number;
     repomixConfig?: RepomixSearchConfig;
     searchTargets?: number;
+    searchBatches?: number;
+    skippedTargets?: number;
     profileId?: string;
     targetsByPattern?: Readonly<Record<string, number>>;
     targetsPreview?: readonly SearchTargetPreview[];