@bli-cockpit/cli 0.1.29 → 0.1.30

package/dist/commands/local-args.js

@@ -26,6 +26,8 @@ export function parseLocalArgs(argv) {
             return parseStartArgs(argv.slice(1));
         case "sync":
             return parseSyncArgs(argv.slice(1));
+        case "backfill":
+            return parseBackfillArgs(argv.slice(1));
         case "status":
             return parseStatusArgs(argv.slice(1));
         case "sessions":
@@ -304,6 +306,52 @@ function parseSyncArgs(args) {
         maxRepos: optionalPositiveInteger(values.flags.get("--max-repos"), "--max-repos"),
     };
 }
+function parseBackfillArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: [
+            "--home",
+            "--repo",
+            "--workspace",
+            "--since-days",
+            "--all",
+            "--source",
+            "--dry-run",
+            "--max-files",
+            "--yes",
+            "--json",
+        ],
+        valueFlags: [
+            "--home",
+            "--repo",
+            "--workspace",
+            "--since-days",
+            "--source",
+            "--max-files",
+        ],
+    });
+    assertNoPositionals(values.positionals, "backfill");
+    const source = values.flags.get("--source");
+    if (source !== undefined && source !== "codex" && source !== "claude") {
+        throw new Error("--source must be 'codex' or 'claude'. Omit it to scan both.");
+    }
+    const sinceDays = optionalPositiveInteger(values.flags.get("--since-days"), "--since-days");
+    const all = values.booleans.has("--all");
+    if (all && sinceDays !== undefined) {
+        throw new Error("--since-days and --all cannot be combined.");
+    }
+    return {
+        kind: "backfill",
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        repoRoot: optionalNonEmpty(workRootFlagValue(values)),
+        source,
+        sinceDays,
+        all,
+        dryRun: values.booleans.has("--dry-run"),
+        maxFiles: optionalPositiveInteger(values.flags.get("--max-files"), "--max-files"),
+        yes: values.booleans.has("--yes"),
+        json: values.booleans.has("--json"),
+    };
+}
 function parseStatusArgs(args) {
     const values = parseNamedArgs(args, {
         allowedFlags: [
@@ -339,6 +387,8 @@ function parseSessionsArgs(args) {
             "--repo",
             "--workspace",
             "--source",
+            "--since-days",
+            "--all",
             "--json",
             "--max-depth",
             "--max-repos",
@@ -348,6 +398,7 @@ function parseSessionsArgs(args) {
             "--repo",
             "--workspace",
             "--source",
+            "--since-days",
             "--max-depth",
             "--max-repos",
         ],
@@ -355,13 +406,20 @@ function parseSessionsArgs(args) {
     assertNoPositionals(values.positionals, "sessions");
     const source = values.flags.get("--source");
     if (source !== undefined && source !== "codex" && source !== "claude") {
-        throw new Error("--source must be 'codex' or 'claude'.");
+        throw new Error("--source must be 'codex' or 'claude'. Omit it to scan both.");
+    }
+    const sinceDays = optionalPositiveInteger(values.flags.get("--since-days"), "--since-days");
+    const all = values.booleans.has("--all");
+    if (all && sinceDays !== undefined) {
+        throw new Error("--since-days and --all cannot be combined.");
     }
     return {
         kind: "sessions",
         homeDir: optionalNonEmpty(values.flags.get("--home")),
         repoRoot: optionalNonEmpty(workRootFlagValue(values)),
         source,
+        sinceDays,
+        all,
         json: values.booleans.has("--json"),
         maxDepth: optionalPositiveInteger(values.flags.get("--max-depth"), "--max-depth"),
         maxRepos: optionalPositiveInteger(values.flags.get("--max-repos"), "--max-repos"),

package/dist/commands/local.js

@@ -1,14 +1,17 @@
 import { execFile, spawn } from "node:child_process";
-import { readFile } from "node:fs/promises";
+import { access, readdir, readFile, stat } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { createCollectorServer } from "../server.js";
 import { inspectAgentRules, installAgentRules, uninstallAgentRules, } from "../agent-rules.js";
+import { runBackfillCommand } from "./backfill.js";
+import { inspectBackfillLock } from "../backfill-lock.js";
 import { parseLocalArgs, normalizeUrl } from "./local-args.js";
 import { autostartStatus, installAutostartAgent, uninstallAutostartAgent, } from "../autostart.js";
 import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths, inspectLocalCollectorStatus, installLocalCollector, logoutLocalCollector, pairLocalCollector, readLocalCollectorConfig, readLocalCollectorSessionFile, readLocalSessionReference, startLocalWorkContext, } from "../local-state.js";
-import { CODEX_ATTRIBUTION_BACKFILL_SESSION_LIMIT, CODEX_ATTRIBUTION_BACKFILL_SINCE_MINUTES, defaultCodexSessionDirs, scanAndAttributeCodexSessions, } from "../adapters/codex-attribution.js";
+import { CODEX_ATTRIBUTION_SCAN_WINDOW_SESSION_LIMIT, CODEX_ATTRIBUTION_SCAN_WINDOW_MINUTES, defaultCodexSessionDirs, scanAndAttributeCodexSessions, } from "../adapters/codex-attribution.js";
 import { scanAndAttributeClaudeSessions } from "../adapters/claude-attribution.js";
+import { backfillCompletionMarkerPath, readBackfillCursor, } from "../cursors/backfill-cursor.js";
 import { acquireSyncLock } from "../sync-lock.js";
 import { discoverGitWorktrees } from "../repo-identity.js";
 import { runAttributedWorktreeSync, } from "./session-sync.js";
@@ -23,6 +26,7 @@ export const rootCommandNames = new Set([
     "logout",
     "start",
     "sync",
+    "backfill",
     "status",
     "sessions",
     "serve",
@@ -61,6 +65,8 @@ export async function runLocalCockpitCli(argv, io = defaultIo()) {
                 return await runStart(command, io);
             case "sync":
                 return await runSync(command, io);
+            case "backfill":
+                return await runBackfillCommand(command, io);
             case "status":
                 return await runStatus(command, io);
             case "sessions":
@@ -93,8 +99,9 @@ export function localCommandHelp(command) {
         "  cockpit logout",
         "  cockpit start [--ticket <id>|--clear-ticket] [--topic <label>] [--intent <intent>] [--phase <phase>] [--workspace <path>] [--branch <name>] [--max-depth <n>] [--max-repos <n>] [--json]",
         "  cockpit sync [--workspace <path>] [--dashboard-url <url>] [--max-depth <n>] [--max-repos <n>] [--json]",
+        "  cockpit backfill (--since-days <n>|--all) [--source codex|claude] [--dry-run] [--max-files <n>] [--yes] [--workspace <path>] [--json]",
         "  cockpit status [--workspace <path>] [--max-depth <n>] [--max-repos <n>] [--json]",
-        "  cockpit sessions [--source codex|claude] [--workspace <path>] [--max-depth <n>] [--max-repos <n>] [--json]",
+        "  cockpit sessions [--source codex|claude] [--since-days <n>|--all] [--workspace <path>] [--max-depth <n>] [--max-repos <n>] [--json]",
         "  cockpit serve [--port <port>] [--workspace <path>]",
         "  cockpit autostart [install|uninstall|status] [--workspace <path>] [--dashboard-url <url>] [--interval-seconds <n>] [--json]",
         "  cockpit agent-rules [install|uninstall|status] [--host codex|claude|all] [--workspace <path>] [--json]",
@@ -198,6 +205,18 @@ function localSubcommandHelp(command) {
                 "--max-depth and --max-repos.",
             ],
         ],
+        [
+            "backfill",
+            [
+                "Usage: cockpit backfill (--since-days <n>|--all) [--source codex|claude] [--dry-run] [--max-files <n>] [--yes] [--workspace <path>] [--json]",
+                "",
+                "Backfills historical Codex and Claude Code session evidence using the saved collection roots from local config when --workspace is omitted.",
+                "Omit --source to scan both sources; there is no --source all literal.",
+                "The non-all window is capped at the collector session paired_at timestamp.",
+                "--all requires a dry-run review and TTY confirmation; pass --yes for headless agent runs.",
+                "--dry-run validates the paired collector and dashboard reachability, prints the same summary tables, and writes nothing.",
+            ],
+        ],
         [
             "status",
             [
@@ -210,12 +229,13 @@ function localSubcommandHelp(command) {
         [
             "sessions",
             [
-                "Usage: cockpit sessions [--source codex|claude] [--workspace <path>] [--json]",
+                "Usage: cockpit sessions [--source codex|claude] [--since-days <n>|--all] [--workspace <path>] [--json]",
                 "",
                 "Read-only: re-runs Codex + Claude session attribution and prints each",
                 "session's id, source, state, reason, scores, signals, and per-sidecar",
                 "skip reasons. No upload, no cursor writes. Answers \"why is session X",
                 "missing?\" locally — counts and labels only, never paths or content.",
+                "--since-days uses the same paired_at cap as `cockpit backfill`; --all scans the full local history.",
                 "`--repo <path>` remains supported as a backward-compatible alias.",
             ],
         ],
@@ -638,6 +658,8 @@ function writeOnboardLiveStatus(io, command, roots, options) {
     writeLine(io.stdout, `Initial sync: ${options.initialSyncOk ? options.sync?.status ?? "uploaded" : "blocked"}`);
     writeLine(io.stdout, `Agent rules: ${options.agentRules ? onboardAgentRulesInstallLine(options.agentRules) : "not refreshed"}`);
     writeLine(io.stdout, `Dashboard: ${command.dashboardUrl}/my-work`);
+    if (options.backfillHint)
+        writeLine(io.stdout, options.backfillHint);
     writeLine(io.stdout, "Next: cockpit status");
 }
 function backgroundSyncLine(result) {
@@ -660,6 +682,7 @@ async function runOnboard(command, io) {
     let rootsResult = null;
     let agentRules = null;
     let autostart = null;
+    let backfillHint = null;
     try {
         if (!command.json) {
             writeLine(io.stdout, "Cockpit harvest onboarding");
@@ -667,6 +690,7 @@ async function runOnboard(command, io) {
             writeLine(io.stdout, `Ticket: ${command.activeTicketId ?? "general ambient"}`);
         }
         const paths = getCollectorRuntimePaths(command.homeDir);
+        backfillHint = await onboardBackfillHint(command.homeDir);
         const existingConfig = await readLocalCollectorConfig(paths).catch(() => null);
         const interactive = !command.json && isInteractiveStdin(io);
         rootsResult = await resolveOnboardingRoots({
@@ -756,6 +780,7 @@ async function runOnboard(command, io) {
                     root_resolution: rootsResult,
                     agent_rules: agentRules,
                     autostart,
+                    backfill_hint: backfillHint,
                     mode: "multi_repo",
                     repos: multi.results,
                     codex_sessions: multi.codex_sessions,
@@ -769,6 +794,7 @@ async function runOnboard(command, io) {
                     agentRules,
                     autostart,
                     initialSyncOk: true,
+                    backfillHint,
                 });
             }
             return multi.ok ? 0 : 1;
@@ -828,6 +854,7 @@ async function runOnboard(command, io) {
                 root_resolution: rootsResult,
                 agent_rules: agentRules,
                 autostart,
+                backfill_hint: backfillHint,
                 codex_sessions: run.summary,
             }, null, 2));
             return 0;
@@ -853,6 +880,7 @@ async function runOnboard(command, io) {
             agentRules,
             autostart,
             initialSyncOk: true,
+            backfillHint,
         });
         return 0;
     }
@@ -981,6 +1009,8 @@ function cursorStatusLine(sync) {
 }
 const DEFAULT_DISCOVERY_MAX_DEPTH = 3;
 const DEFAULT_DISCOVERY_MAX_REPOS = 50;
+const ALL_SESSION_SCAN_WINDOW_MINUTES = 20 * 365 * 24 * 60;
+const SESSION_SCAN_OVERRIDE_LIMIT = 10_000;
 async function discoverCommandWorktrees(repoRoot, discovery = {}, io) {
     if (Array.isArray(repoRoot)) {
         const discovered = [];
@@ -1223,6 +1253,20 @@ async function runStart(command, io) {
     return 0;
 }
 async function runSync(command, io) {
+    const backfillLock = await inspectBackfillLock(getCollectorRuntimePaths(command.homeDir));
+    if (backfillLock.held) {
+        if (command.json) {
+            writeLine(io.stdout, JSON.stringify({
+                status: "live_sync_paused_during_backfill",
+                reason: "live sync paused during backfill",
+                held_since: backfillLock.held_since,
+            }, null, 2));
+        }
+        else {
+            writeLine(io.stdout, "live sync paused during backfill");
+        }
+        return 0;
+    }
     // Single-flight: a launchd timer and a manual sync must not interleave the
     // cursor read-modify-write. A blocked invocation exits cleanly (B.4 §7).
     const lock = await acquireSyncLock(getCollectorRuntimePaths(command.homeDir));
@@ -1301,6 +1345,7 @@ async function runSyncLocked(command, io) {
     return 1;
 }
 async function runStatus(command, io) {
+    const backfillCursor = await inspectBackfillCursor(command.homeDir);
     const worktrees = await discoverCommandWorktrees(command.repoRoot, { maxDepth: command.maxDepth, maxRepos: command.maxRepos }, io);
     if (worktrees.length > 1) {
         const statuses = await Promise.all(worktrees.map(async (worktree) => ({
@@ -1311,10 +1356,11 @@ async function runStatus(command, io) {
             head_sha: worktree.head_sha,
         })));
         if (command.json) {
-            writeLine(io.stdout, JSON.stringify({ mode: "multi_repo", statuses }, null, 2));
+            writeLine(io.stdout, JSON.stringify({ mode: "multi_repo", statuses, backfill_cursor: backfillCursor }, null, 2));
             return 0;
         }
         writeLine(io.stdout, "Cockpit parent status");
+        writeLine(io.stdout, `backfill: ${backfillCursorLine(backfillCursor)}`);
         for (const status of statuses) {
             writeLine(io.stdout, `- ${status.repo_label ?? status.repo}/${status.worktree_label ?? "worktree"} · ${status.branch} · head:${shortSha(status.head_sha)} · ${status.upload_state}`);
         }
@@ -1322,7 +1368,7 @@ async function runStatus(command, io) {
     }
     const status = await inspectLocalCollectorStatus(command);
     if (command.json) {
-        writeLine(io.stdout, JSON.stringify(status, null, 2));
+        writeLine(io.stdout, JSON.stringify({ ...status, backfill_cursor: backfillCursor }, null, 2));
         return 0;
     }
     writeLine(io.stdout, "Cockpit local status");
@@ -1339,6 +1385,7 @@ async function runStatus(command, io) {
     writeLine(io.stdout, `last_upload_success: ${status.last_upload_success_at ?? "never"}`);
     writeLine(io.stdout, `last_upload_failure: ${status.last_upload_failure_reason ?? "none"}`);
     writeLine(io.stdout, `pending_uploads: ${status.pending_upload_count}`);
+    writeLine(io.stdout, `backfill: ${backfillCursorLine(backfillCursor)}`);
     for (const detail of status.details)
         writeLine(io.stdout, `- ${detail}`);
     return 0;
@@ -1351,6 +1398,251 @@ function displayWorkLabel(status) {
         return `${status.work_label} (${status.work_id})`;
     return status.work_label ?? status.work_id ?? "no active work context";
 }
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function onboardBackfillHint(homeDir) {
+    const paths = getCollectorRuntimePaths(homeDir);
+    if (await fileExists(backfillCompletionMarkerPath(paths)))
+        return null;
+    const hasArchivedSessions = await hasAnyJsonlFile([
+        path.join(homeDir ?? os.homedir(), ".codex", "archived_sessions"),
+    ]);
+    return hasArchivedSessions
+        ? "Backfill: archived sessions found. Run `cockpit backfill --all` to include older local history."
+        : null;
+}
+async function inspectBackfillCursor(homeDir) {
+    const paths = getCollectorRuntimePaths(homeDir);
+    const marker = await readBackfillCompletionMarker(paths);
+    if (marker) {
+        return {
+            state: "done",
+            remaining_count: 0,
+            updated_at: marker.cursor.updated_at,
+            completed_at: marker.completed_at,
+            sources: summarizeBackfillCursorSources(marker.cursor),
+        };
+    }
+    const cursor = await readBackfillCursor(paths);
+    if (!cursor.updated_at) {
+        return {
+            state: "never_run",
+            remaining_count: 0,
+            updated_at: null,
+            completed_at: null,
+            sources: summarizeBackfillCursorSources(cursor),
+        };
+    }
+    return {
+        state: "remaining",
+        remaining_count: await countRemainingBackfillSessionFiles(homeDir ?? os.homedir(), cursor),
+        updated_at: cursor.updated_at,
+        completed_at: null,
+        sources: summarizeBackfillCursorSources(cursor),
+    };
+}
+async function readBackfillCompletionMarker(paths) {
+    try {
+        const raw = JSON.parse(await readFile(backfillCompletionMarkerPath(paths), "utf8"));
+        if (typeof raw.completed_at !== "string")
+            return null;
+        const cursor = raw.cursor && typeof raw.cursor === "object"
+            ? normalizeBackfillCursor(raw.cursor)
+            : await readBackfillCursor(paths);
+        return { completed_at: raw.completed_at, cursor };
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeBackfillCursor(value) {
+    const record = value;
+    return {
+        schema_version: "cockpit-backfill-cursor.v1",
+        updated_at: typeof record.updated_at === "string" && record.updated_at
+            ? record.updated_at
+            : null,
+        sources: {
+            codex: {
+                oldest_mtime_ms_processed: typeof record.sources?.codex?.oldest_mtime_ms_processed === "number"
+                    ? record.sources.codex.oldest_mtime_ms_processed
+                    : null,
+                oldest_mtime_processed: typeof record.sources?.codex?.oldest_mtime_processed === "string"
+                    ? record.sources.codex.oldest_mtime_processed
+                    : null,
+                state_counts: numberRecord(record.sources?.codex?.state_counts),
+                reason_counts: numberRecord(record.sources?.codex?.reason_counts),
+            },
+            claude_code: {
+                oldest_mtime_ms_processed: typeof record.sources?.claude_code?.oldest_mtime_ms_processed === "number"
+                    ? record.sources.claude_code.oldest_mtime_ms_processed
+                    : null,
+                oldest_mtime_processed: typeof record.sources?.claude_code?.oldest_mtime_processed === "string"
+                    ? record.sources.claude_code.oldest_mtime_processed
+                    : null,
+                state_counts: numberRecord(record.sources?.claude_code?.state_counts),
+                reason_counts: numberRecord(record.sources?.claude_code?.reason_counts),
+            },
+        },
+    };
+}
+function numberRecord(value) {
+    if (!value || typeof value !== "object")
+        return {};
+    const out = {};
+    for (const [key, raw] of Object.entries(value)) {
+        if (typeof raw === "number" && Number.isFinite(raw))
+            out[key] = raw;
+    }
+    return out;
+}
+function summarizeBackfillCursorSources(cursor) {
+    return {
+        codex: summarizeBackfillSource(cursor.sources.codex),
+        claude_code: summarizeBackfillSource(cursor.sources.claude_code),
+    };
+}
+function summarizeBackfillSource(source) {
+    return {
+        oldest_mtime_processed: source.oldest_mtime_processed,
+        observed_count: Object.values(source.state_counts).reduce((total, count) => total + count, 0),
+        state_counts: source.state_counts,
+        reason_counts: source.reason_counts,
+    };
+}
+function backfillCursorLine(status) {
+    switch (status.state) {
+        case "done":
+            return `done (${status.completed_at ?? "completion marker present"})`;
+        case "never_run":
+            return "never run";
+        case "remaining":
+            return `${status.remaining_count} remaining`;
+    }
+}
+async function countRemainingBackfillSessionFiles(homeDir, cursor) {
+    const codex = await countJsonlFilesBeforeCursor(defaultCodexSessionDirs(homeDir), cursor.sources.codex.oldest_mtime_ms_processed);
+    const claude = await countClaudeMainFilesBeforeCursor(path.join(homeDir, ".claude", "projects"), cursor.sources.claude_code.oldest_mtime_ms_processed);
+    return codex + claude;
+}
+async function countJsonlFilesBeforeCursor(roots, oldestProcessedMs) {
+    let count = 0;
+    await walkFiles(roots, async (filePath, entryName) => {
+        if (!entryName.endsWith(".jsonl"))
+            return;
+        const info = await stat(filePath).catch(() => null);
+        if (!info?.isFile())
+            return;
+        if (oldestProcessedMs === null || info.mtimeMs < oldestProcessedMs)
+            count += 1;
+    });
+    return count;
+}
+async function countClaudeMainFilesBeforeCursor(projectsDir, oldestProcessedMs) {
+    let count = 0;
+    await walkFiles([projectsDir], async (filePath, entryName) => {
+        if (!entryName.endsWith(".jsonl"))
+            return;
+        if (filePath.includes(`${path.sep}subagents${path.sep}`))
+            return;
+        const info = await stat(filePath).catch(() => null);
+        if (!info?.isFile())
+            return;
+        if (oldestProcessedMs === null || info.mtimeMs < oldestProcessedMs)
+            count += 1;
+    });
+    return count;
+}
+async function hasAnyJsonlFile(roots) {
+    let found = false;
+    await walkFiles(roots, async (_filePath, entryName) => {
+        if (entryName.endsWith(".jsonl"))
+            found = true;
+    }, () => found);
+    return found;
+}
+async function walkFiles(roots, onFile, shouldStop = () => false) {
+    const stack = [...roots];
+    while (stack.length > 0 && !shouldStop()) {
+        const current = stack.pop();
+        if (!current)
+            continue;
+        let entries;
+        try {
+            entries = await readdir(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (shouldStop())
+                return;
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(full);
+            }
+            else if (entry.isFile()) {
+                await onFile(full, entry.name);
+            }
+        }
+    }
+}
+async function sessionsScanWindow(command, now) {
+    if (command.all) {
+        return {
+            mode: "all",
+            since_days: null,
+            started_at: new Date(now.getTime() - ALL_SESSION_SCAN_WINDOW_MINUTES * 60_000)
+                .toISOString(),
+            paired_at: await readPairedAt(command.homeDir),
+            since_minutes: ALL_SESSION_SCAN_WINDOW_MINUTES,
+            limit: SESSION_SCAN_OVERRIDE_LIMIT,
+        };
+    }
+    if (command.sinceDays !== undefined) {
+        const requestedMs = now.getTime() - command.sinceDays * 24 * 60 * 60_000;
+        const pairedAt = await readPairedAt(command.homeDir);
+        const pairedMs = pairedAt ? Date.parse(pairedAt) : Number.NaN;
+        const startedAtMs = Number.isFinite(pairedMs)
+            ? Math.max(requestedMs, pairedMs)
+            : requestedMs;
+        return {
+            mode: "since_days",
+            since_days: command.sinceDays,
+            started_at: new Date(startedAtMs).toISOString(),
+            paired_at: pairedAt,
+            since_minutes: Math.max(1, Math.ceil((now.getTime() - startedAtMs) / 60_000)),
+            limit: SESSION_SCAN_OVERRIDE_LIMIT,
+        };
+    }
+    return {
+        mode: "default",
+        since_days: null,
+        started_at: null,
+        paired_at: await readPairedAt(command.homeDir),
+        since_minutes: null,
+        limit: CODEX_ATTRIBUTION_SCAN_WINDOW_SESSION_LIMIT,
+    };
+}
+async function readPairedAt(homeDir) {
+    const session = await readLocalCollectorSessionFile(getCollectorRuntimePaths(homeDir)).catch(() => null);
+    return typeof session?.paired_at === "string" ? session.paired_at : null;
+}
+function sessionsWindowLine(window) {
+    if (window.mode === "all")
+        return "all local history";
+    if (window.mode === "since_days") {
+        return `since ${window.started_at} (${window.since_days} day request, paired_at cap ${window.paired_at ?? "unavailable"})`;
+    }
+    return "default scan window";
+}
 /**
  * Read-only diagnostic: re-runs attribution (no upload, no cursor writes) and
  * prints why each session is or is not collected. Per-session reasons otherwise
@@ -1362,6 +1654,7 @@ async function runSessions(command, io) {
     const now = new Date();
     const homeDir = command.homeDir ?? os.homedir();
     const worktrees = await discoverCommandWorktrees(command.repoRoot, { maxDepth: command.maxDepth, maxRepos: command.maxRepos }, io);
+    const window = await sessionsScanWindow(command, now);
     const wantCodex = command.source !== "claude";
     const wantClaude = command.source !== "codex";
     const codex = wantCodex
@@ -1369,8 +1662,8 @@ async function runSessions(command, io) {
             sessionsDirs: defaultCodexSessionDirs(homeDir),
             worktrees,
             now,
-            sinceMinutes: CODEX_ATTRIBUTION_BACKFILL_SINCE_MINUTES,
-            limit: CODEX_ATTRIBUTION_BACKFILL_SESSION_LIMIT,
+            sinceMinutes: window.since_minutes ?? CODEX_ATTRIBUTION_SCAN_WINDOW_MINUTES,
+            limit: window.limit,
         })
         : null;
     const claude = wantClaude
@@ -1378,6 +1671,8 @@ async function runSessions(command, io) {
             projectsDir: path.join(homeDir, ".claude", "projects"),
             worktrees,
             now,
+            sinceMinutes: window.since_minutes ?? undefined,
+            limit: window.mode === "default" ? undefined : window.limit,
         })
         : null;
     // Safe output contract (B.4 §6): id, state, reason, scores, signals, sidecar
@@ -1412,6 +1707,7 @@ async function runSessions(command, io) {
     }));
     if (command.json) {
         writeLine(io.stdout, JSON.stringify({
+            window,
             ...(codex
                 ? { codex: { counts: codex.counts, sessions: codexRows } }
                 : {}),
@@ -1428,6 +1724,7 @@ async function runSessions(command, io) {
         return 0;
     }
     writeLine(io.stdout, "Cockpit sessions (read-only attribution)");
+    writeLine(io.stdout, `window: ${sessionsWindowLine(window)}`);
     for (const row of codexRows) {
         writeLine(io.stdout, sessionRowLine(row));
     }