@bli-cockpit/cli 0.1.19 → 0.1.21

package/README.md

@@ -46,19 +46,21 @@ On machines where Codex or Claude agents will do ticketed work, interactive
 `cockpit onboard` checks `~/.codex/AGENTS.md` and `~/.claude/CLAUDE.md` after
 harvest proof. If equivalent Cockpit ticket-binding guidance already exists, it
 leaves the files alone. If guidance is missing or clearly stale, it asks whether
-to install or replace it.
+to install or replace it. The managed guidance is scoped to the workspace path
+used for onboarding, so agents should ignore it in private chats or unrelated
+repos.
 
 ```bash
 # Repair/manual path, or headless/json onboarding where Cockpit cannot prompt.
-cockpit agent-rules install
+cockpit agent-rules install --workspace "$PWD"
 ```
 
 The direct command updates `~/.codex/AGENTS.md` and `~/.claude/CLAUDE.md` with
 the Cockpit rule to bind known Linear tickets before edits, or ask once when
-the ticket ID is missing. That binding starts attributing the session's work to
-the specific ticket in Cockpit. It checks for managed or equivalent guidance
-first, so current files are left unchanged and stale Cockpit ticket-binding
-sections are replaced.
+the ticket ID is missing inside that workspace. That binding starts attributing
+the session's work to the specific ticket in Cockpit. It checks for managed or
+equivalent guidance first, so current files are left unchanged and stale Cockpit
+ticket-binding sections are replaced.
 
 Parent mode scans child git repos/worktrees (3 folder levels deep, up to 50
 repos by default — tune with `--max-depth` / `--max-repos`; a warning prints
@@ -113,6 +115,30 @@ cockpit sync \
 No ticket is required for setup, chatting, planning, or general ambient capture.
 Only pass `--ticket` when the work really belongs to a visible ticket.
 
+When the work is important but ticketless, label it explicitly before syncing so
+later analysis does not have to guess the topic:
+
+```bash
+cockpit start \
+  --workspace "$PWD" \
+  --topic "lead ingestion rewrite planning" \
+  --intent planning \
+  --phase discovery \
+  --intent-confidence 0.9
+
+cockpit sync \
+  --workspace "$PWD" \
+  --json
+```
+
+Supported `--intent` values are `implementation`, `bug_fix`,
+`root_cause_analysis`, `planning`, `discovery`, `review`, `testing`,
+`documentation`, `release`, `learning`, `coordination`, `maintenance`,
+`analysis`, `unknown`, and `other`. Supported `--phase` values are `planning`,
+`discovery`, `implementation`, `debugging`, `review`, `testing`,
+`documentation`, `release`, `handoff`, `analysis`, `unknown`, and `other`.
+Use `--topic-summary` only for short redacted summaries, not transcript text.
+
 ## What gets saved
 
 Local files:
@@ -180,3 +206,5 @@ This public package intentionally excludes Cockpit admin bootstrap commands,
 service-role credential handling, source maps, tests, and internal runbooks.
 Clean `npm pack` and `npm publish` run the public CLI build before packaging so
 `dist/cli.js` is present in emergency releases.
+When collector changes depend on new telemetry-core exports, publish
+`@bli-cockpit/telemetry-core` first, then publish `@bli-cockpit/cli`.

package/dist/adapters/claude-attribution.js

@@ -54,8 +54,19 @@ export async function scanAndAttributeClaudeSessions(options) {
     const countState = (state) => results.filter((result) => result.state === state).length;
     return {
         results,
+        discovered_session_count: discovery.sessions.length,
         scanned_session_count: sessions.length,
+        since_minutes: sinceMinutes,
+        session_limit: limit,
+        session_limit_applied: discovery.sessions.length > limit,
+        max_file_bytes: CLAUDE_SESSION_MAX_FILE_BYTES,
+        max_sidecar_files: CLAUDE_SESSION_MAX_SIDECAR_FILES,
+        max_line_buffer_bytes: MAX_LINE_BUFFER_BYTES,
         project_dirs_skipped: discovery.projectDirsSkipped,
+        project_dir_read_failed_count: discovery.projectDirReadFailedCount,
+        session_stat_failed_count: discovery.sessionStatFailedCount,
+        sidecar_dir_read_failed_count: discovery.sidecarDirReadFailedCount,
+        sidecar_stat_failed_count: discovery.sidecarStatFailedCount,
         counts: {
             attributed: countState("attributed"),
             ambiguous: countState("ambiguous"),
@@ -72,12 +83,23 @@ export async function scanAndAttributeClaudeSessions(options) {
 async function discoverClaudeSessions(projectsDir, cutoffMs) {
     const sessions = [];
     let projectDirsSkipped = 0;
+    let projectDirReadFailedCount = 0;
+    let sessionStatFailedCount = 0;
+    let sidecarDirReadFailedCount = 0;
+    let sidecarStatFailedCount = 0;
     let projectEntries;
     try {
         projectEntries = await fs.readdir(projectsDir, { withFileTypes: true });
     }
     catch {
-        return { sessions, projectDirsSkipped };
+        return {
+            sessions,
+            projectDirsSkipped,
+            projectDirReadFailedCount: 1,
+            sessionStatFailedCount,
+            sidecarDirReadFailedCount,
+            sidecarStatFailedCount,
+        };
     }
     for (const projectEntry of projectEntries) {
         if (!projectEntry.isDirectory())
@@ -96,6 +118,7 @@ async function discoverClaudeSessions(projectsDir, cutoffMs) {
             sessionEntries = await fs.readdir(projectDir, { withFileTypes: true });
         }
         catch {
+            projectDirReadFailedCount += 1;
             continue;
         }
         for (const sessionEntry of sessionEntries) {
@@ -109,10 +132,14 @@ async function discoverClaudeSessions(projectsDir, cutoffMs) {
                 mainStat = await fs.stat(mainFile);
             }
             catch {
+                sessionStatFailedCount += 1;
                 continue;
             }
             const sessionUuid = sessionEntry.name.replace(/\.jsonl$/i, "");
-            const { sidecars, sidecarsCapped } = await discoverSidecars(path.join(projectDir, sessionUuid, "subagents"));
+            const sidecarDiscovery = await discoverSidecars(path.join(projectDir, sessionUuid, "subagents"));
+            const { sidecars, sidecarsCapped } = sidecarDiscovery;
+            sidecarDirReadFailedCount += sidecarDiscovery.dirReadFailedCount;
+            sidecarStatFailedCount += sidecarDiscovery.statFailedCount;
             const recencyMs = Math.max(mainStat.mtimeMs, ...sidecars.map((sidecar) => sidecar.mtimeMs));
             // D10: a session is recent if its main file OR any sidecar is in window.
             if (recencyMs < cutoffMs)
@@ -127,7 +154,14 @@ async function discoverClaudeSessions(projectsDir, cutoffMs) {
             });
         }
     }
-    return { sessions, projectDirsSkipped };
+    return {
+        sessions,
+        projectDirsSkipped,
+        projectDirReadFailedCount,
+        sessionStatFailedCount,
+        sidecarDirReadFailedCount,
+        sidecarStatFailedCount,
+    };
 }
 async function discoverSidecars(subagentsDir) {
     let entries;
@@ -135,9 +169,15 @@ async function discoverSidecars(subagentsDir) {
         entries = await fs.readdir(subagentsDir, { withFileTypes: true });
     }
     catch {
-        return { sidecars: [], sidecarsCapped: 0 };
+        return {
+            sidecars: [],
+            sidecarsCapped: 0,
+            dirReadFailedCount: 1,
+            statFailedCount: 0,
+        };
     }
     const discovered = [];
+    let statFailedCount = 0;
     for (const entry of entries) {
         // Only agent transcripts. `*.meta.json` carry operator-authored
         // descriptions and are never harvested (D3).
@@ -152,6 +192,7 @@ async function discoverSidecars(subagentsDir) {
             stat = await fs.stat(local_path);
         }
         catch {
+            statFailedCount += 1;
             continue;
         }
         discovered.push({
@@ -166,6 +207,8 @@ async function discoverSidecars(subagentsDir) {
     return {
         sidecars: discovered.slice(0, CLAUDE_SESSION_MAX_SIDECAR_FILES),
         sidecarsCapped: capped,
+        dirReadFailedCount: 0,
+        statFailedCount,
     };
 }
 async function attributeOneSession(session, worktrees) {

package/dist/adapters/codex-attribution.js

@@ -23,14 +23,23 @@ export async function scanAndAttributeCodexSessions(options) {
     const sinceMinutes = options.sinceMinutes ?? CODEX_ATTRIBUTION_DEFAULT_SINCE_MINUTES;
     const limit = options.limit ?? CODEX_ATTRIBUTION_DEFAULT_SESSION_LIMIT;
     const cutoffMs = options.now.getTime() - sinceMinutes * 60 * 1000;
-    const files = (await walkCodexJsonlFiles(options.sessionsDir, cutoffMs)).slice(0, limit);
+    const discovery = await discoverCodexJsonlFiles(options.sessionsDir, cutoffMs);
+    const files = discovery.files.slice(0, limit);
     const results = [];
     for (const file of files) {
         results.push(await attributeOneSession(file, options.worktrees));
     }
     return {
         results,
+        discovered_file_count: discovery.files.length,
         scanned_file_count: files.length,
+        since_minutes: sinceMinutes,
+        session_limit: limit,
+        session_limit_applied: discovery.files.length > limit,
+        max_file_bytes: CODEX_SESSION_MAX_FILE_BYTES,
+        directory_read_failed_count: discovery.directoryReadFailedCount,
+        stat_failed_count: discovery.statFailedCount,
+        secret_path_skipped_count: discovery.secretPathSkippedCount,
         counts: {
             attributed: results.filter((entry) => entry.state === "attributed").length,
             ambiguous: results.filter((entry) => entry.state === "ambiguous").length,
@@ -41,25 +50,40 @@ export async function scanAndAttributeCodexSessions(options) {
     };
 }
 export async function walkCodexJsonlFiles(dir, cutoffMs) {
+    return (await discoverCodexJsonlFiles(dir, cutoffMs)).files;
+}
+async function discoverCodexJsonlFiles(dir, cutoffMs) {
     const out = [];
+    let directoryReadFailedCount = 0;
+    let statFailedCount = 0;
+    let secretPathSkippedCount = 0;
     const stack = [dir];
     while (stack.length > 0) {
         const current = stack.pop();
-        if (!current || isSecretLikePath(current))
+        if (!current)
+            continue;
+        if (isSecretLikePath(current)) {
+            secretPathSkippedCount += 1;
             continue;
+        }
         let entries;
         try {
             entries = await fs.readdir(current, { withFileTypes: true });
         }
         catch {
+            directoryReadFailedCount += 1;
             continue;
         }
         for (const entry of entries) {
             const full = path.join(current, entry.name);
             if (entry.isDirectory()) {
                 // Never descend into secret-like directories.
-                if (!isSecretLikePath(full))
+                if (isSecretLikePath(full)) {
+                    secretPathSkippedCount += 1;
+                }
+                else {
                     stack.push(full);
+                }
                 continue;
             }
             // Secret-like file NAMES stay in the list so attribution can record a
@@ -67,14 +91,26 @@ export async function walkCodexJsonlFiles(dir, cutoffMs) {
             // instead of silently dropping the session.
             if (!entry.isFile() || !entry.name.endsWith(".jsonl"))
                 continue;
-            const stat = await fs.stat(full);
+            let stat;
+            try {
+                stat = await fs.stat(full);
+            }
+            catch {
+                statFailedCount += 1;
+                continue;
+            }
             if (stat.mtimeMs >= cutoffMs) {
                 out.push({ file: full, mtimeMs: stat.mtimeMs, byteSize: stat.size });
             }
         }
     }
     out.sort((a, b) => b.mtimeMs - a.mtimeMs);
-    return out;
+    return {
+        files: out,
+        directoryReadFailedCount,
+        statFailedCount,
+        secretPathSkippedCount,
+    };
 }
 async function attributeOneSession(file, worktrees) {
     const fileName = path.basename(file.file);

package/dist/adapters/local-sources.js

@@ -28,7 +28,9 @@ export async function runLocalSourceCollectors(options) {
             includeCodexJsonl: options.rawEvidenceIncludeCodexJsonl,
             includeClaudeJsonl: options.rawEvidenceIncludeClaudeJsonl,
             codexSessionFiles: options.rawEvidenceCodexSessionFiles,
+            codexAttributionScan: options.rawEvidenceCodexAttributionScan,
             claudeSessionFiles: options.rawEvidenceClaudeSessionFiles,
+            claudeAttributionScan: options.rawEvidenceClaudeAttributionScan,
             skipContentHashes: options.rawEvidenceSkipContentHashes,
             byteBudget: options.rawEvidenceByteBudget,
             objectBudget: options.rawEvidenceObjectBudget,