@bli-cockpit/cli 0.1.22 → 0.1.24

package/README.md

@@ -11,27 +11,35 @@ device pairing.
 
 ## One-paste install
 
-Run this from the repo where work will happen:
+Run this in a terminal. If you are inside `~/BLI`, Cockpit suggests that
+workspace root; otherwise it looks for likely roots such as `~/BLI` and asks
+before collecting. Later reruns remember the approved roots:
 
 ```bash
 npm install -g @bli-cockpit/cli@latest
-cockpit onboard --workspace "$PWD"
+cockpit onboard
 ```
 
 Interactive onboarding prompts for the dashboard email. Enter the approved
 intern/operator email. For reused laptops, VMs, or headless/agent-run setup,
-pass the email explicitly:
+pass the email and root explicitly:
 
 ```bash
-cockpit onboard --email <APPROVED_EMAIL> --workspace "$PWD"
+cockpit onboard --email <APPROVED_EMAIL> --workspace ~/BLI
 ```
 
-If a work folder contains multiple repos, run the same command from the parent:
+If a work folder contains multiple repos, confirm the parent folder as the
+collection root. In a headless setup, pass it explicitly:
 
 ```bash
-cd ~/Downloads/bluepearl-workspace
 npm install -g @bli-cockpit/cli@latest
-cockpit onboard --workspace "$PWD"
+cockpit onboard --email <APPROVED_EMAIL> --workspace ~/BLI
+```
+
+For multiple unrelated collection roots, repeat `--workspace`:
+
+```bash
+cockpit onboard --email <APPROVED_EMAIL> --workspace ~/BLI --workspace ~/side-projects
 ```
 
 The CLI defaults to the production dashboard. Normal intern/operator setup,
@@ -39,25 +47,23 @@ updates, and syncs omit `--dashboard-url`. Pass `--dashboard-url` only for
 staging, a custom dashboard, or deliberately forcing a different dashboard
 pairing. Already-onboarded users update with
 `npm install -g @bli-cockpit/cli@latest`, then run
-`cockpit sync --workspace "$PWD" --json`. `--repo <path>` remains supported
-for older prompts and the agent ticket-binding guardrail.
-
-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. The managed guidance is scoped to the workspace path
-used for onboarding, so agents should ignore it in private chats or unrelated
-repos.
-
-For intern machines, accept the onboarding prompt to keep Cockpit syncing in the
-background. It installs the launchd autostart agent so Cockpit syncs at login
-and every 15 minutes. If skipped, run
-`cockpit autostart install --workspace "$PWD"` later.
+`cockpit onboard` from anywhere to refresh pairing, agent rules, autostart, and
+an initial sync against saved roots. `--repo <path>` remains supported for older
+prompts and the agent ticket-binding guardrail.
+
+On machines where Codex or Claude agents will do ticketed work, `cockpit
+onboard` refreshes `~/.codex/AGENTS.md` and `~/.claude/CLAUDE.md` after harvest
+proof. The managed Cockpit ticket-binding block is replaced in place rather
+than duplicated and is scoped to the confirmed root set, so agents should ignore
+it in private chats or unrelated repos.
+
+For intern machines, `cockpit onboard` refreshes the launchd autostart agent so
+Cockpit syncs confirmed roots at login and every 15 minutes. For a manual
+repair path, run `cockpit autostart install --workspace <root>` later.
 
 ```bash
-# Repair/manual path, or headless/json onboarding where Cockpit cannot prompt.
-cockpit agent-rules install --workspace "$PWD"
+# Repair/manual path.
+cockpit agent-rules install --workspace <root>
 ```
 
 The direct command updates `~/.codex/AGENTS.md` and `~/.claude/CLAUDE.md` with
@@ -87,16 +93,21 @@ What happens:
 4. Admin approves the persistent email access request from Ambient -> Collector
    approvals. Pair codes still expire, but the access request remains. If the
    terminal is still polling, approval pairs it immediately; if not, the intern
-   reruns `cockpit onboard --email <APPROVED_EMAIL> --workspace "$PWD"` and the
-   stored approval auto-pairs without another Admin action. Admin can still
-   paste the printed code there as a rescue path. The signed-in intern can still
-   use the printed URL. If the claimed email is not an app user yet, a super
-   admin approval creates the user, adds team membership, and sends the
-   Supabase invite flow automatically.
+   reruns `cockpit onboard --email <APPROVED_EMAIL> --workspace ~/BLI` or
+   simply `cockpit onboard` after roots are saved, and the stored approval
+   auto-pairs without another Admin action. Admin can still paste the printed
+   code there as a rescue path. The signed-in intern can still use the printed
+   URL. If the claimed email is not an app user yet, a super admin approval
+   creates the user, adds team membership, and sends the Supabase invite flow
+   automatically.
 5. The CLI starts general ambient capture, uploads private raw evidence objects
    when present (chunked and resumable, with identical content acknowledged
-   instead of re-uploaded), then uploads one safe metadata/ref envelope.
-6. The CLI prints `PASS: Cockpit collector is ready for harvest.`
+   instead of re-uploaded), then uploads one safe metadata/ref envelope. Text
+   evidence with secret-shaped values is sanitized before storage and marked as
+   partial evidence with redaction metadata; env files are still never read.
+6. The CLI prints `PASS: Cockpit collector is ready for harvest.` and a final
+   `You're live.` block with collection roots, pairing state, background sync
+   state, dashboard link, and `cockpit status` as the next command.
 
 `--device-name` is optional and only a readable label in Cockpit. Pass it only
 when you want a specific label such as `"Savina MacBook"` or `"Box VM 42"`.
@@ -173,7 +184,9 @@ Remote dashboard:
 - raw evidence refs accepted by `/api/ambient/ingest`;
 - durable private Storage objects accepted by the chunked
   `/api/ambient/evidence/upload/begin|chunk|commit` endpoints, tracked in a
-  durable per-object upload ledger;
+  durable per-object upload ledger. When deterministic sanitization was
+  applied, the evidence ref stores the redaction metadata and sanitized object
+  hash/size;
 - attached image artifact metadata accepted by `/api/ambient/agent-artifacts`
   for screenshots/images explicitly attached into Codex or Claude sessions;
 - Codex session attribution records (session id, file hash, attribution state

package/dist/adapters/raw-evidence.js

@@ -1,4 +1,4 @@
-import { EvidenceCompletenessPayloadSchema, SECRET_FILE_SEGMENT_PATTERN, SourceScanResultSchema, containsSecretLikeContent, } from "@bli-cockpit/telemetry-core";
+import { EvidenceCompletenessPayloadSchema, SECRET_FILE_SEGMENT_PATTERN, SourceScanResultSchema, containsSecretLikeContent, redactSecretLikeContent, } from "@bli-cockpit/telemetry-core";
 import { spawn } from "node:child_process";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
@@ -29,6 +29,7 @@ export async function collectRawEvidencePack(context, options) {
     const skipped = [];
     const truncated = [];
     const failed = [];
+    const redacted = [];
     const reused = [];
     const sinceMinutes = options.sinceMinutes ?? DEFAULT_SINCE_MINUTES;
     const sessionLimit = options.sessionLimit ?? DEFAULT_SESSION_LIMIT;
@@ -42,6 +43,7 @@ export async function collectRawEvidencePack(context, options) {
         skipped,
         truncated,
         failed,
+        redacted,
         reused,
         scanned: new Map(),
         caps: [
@@ -126,6 +128,7 @@ export async function collectRawEvidencePack(context, options) {
                 file_count: 0,
                 byte_size: 0,
                 skipped_count: countEvidenceEntries(skipped),
+                sanitized_count: redacted.length,
                 reused_count: reused.length,
                 deferred_byte_budget_count: deferredByteBudgetCount,
                 deferred_object_budget_count: deferredObjectBudgetCount,
@@ -150,6 +153,7 @@ export async function collectRawEvidencePack(context, options) {
             packId,
             entries,
             skipped,
+            redacted,
             reused,
         });
         const manifestPath = path.join(evidenceDir, "manifest.json");
@@ -180,6 +184,7 @@ export async function collectRawEvidencePack(context, options) {
             file_count: entries.length,
             byte_size: entries.reduce((sum, entry) => sum + entry.byte_size, 0),
             skipped_count: countEvidenceEntries(skipped),
+            sanitized_count: redacted.length,
             reused_count: reused.length,
             deferred_byte_budget_count: deferredByteBudgetCount,
             deferred_object_budget_count: deferredObjectBudgetCount,
@@ -225,6 +230,7 @@ export async function collectRawEvidencePack(context, options) {
             file_count: 0,
             byte_size: 0,
             skipped_count: countEvidenceEntries(skipped),
+            sanitized_count: redacted.length,
             reused_count: reused.length,
             deferred_byte_budget_count: skipped
                 .filter((entry) => entry.reason === "deferred_byte_budget")
@@ -603,15 +609,29 @@ async function collectOneEvidenceFile(collection, options) {
         });
         return false;
     }
-    if (containsSecretLikeContent(raw.toString("utf8"))) {
+    const sanitized = sanitizeTextEvidenceForUpload({
+        text: raw.toString("utf8"),
+        originalBytes: raw,
+        redactedFields: [`${options.kind}.body`],
+    });
+    if (sanitized.status === "blocked") {
         collection.skipped.push({
             kind: options.kind,
             label: fileName,
-            reason: "secret_like_content_guard",
+            reason: sanitized.reason,
         });
         return false;
     }
-    const contentHash = sha256(raw);
+    if (sanitized.status === "redacted") {
+        collection.redacted.push({
+            kind: options.kind,
+            label: fileName,
+            redaction: sanitized.redaction,
+        });
+    }
+    const evidenceBytes = sanitized.bytes;
+    const redaction = sanitized.redaction;
+    const contentHash = sha256(evidenceBytes);
     if (collection.skipContentHashes.has(contentHash)) {
         collection.reused.push({
             kind: options.kind,
@@ -621,7 +641,7 @@ async function collectOneEvidenceFile(collection, options) {
         });
         return true;
     }
-    const deferReason = admitToBudget(collection.budget, raw.byteLength);
+    const deferReason = admitToBudget(collection.budget, evidenceBytes.byteLength);
     if (deferReason) {
         markBudgetCapApplied(collection, deferReason);
         collection.skipped.push({
@@ -634,7 +654,7 @@ async function collectOneEvidenceFile(collection, options) {
     collection.index.value += 1;
     const relativePath = path.join("files", `${String(collection.index.value).padStart(3, "0")}-${shortHash(options.filePath)}-${fileName}`);
     const destination = path.join(collection.filesDir, path.basename(relativePath));
-    await fs.writeFile(destination, raw, { mode: 0o600 });
+    await fs.writeFile(destination, evidenceBytes, { mode: 0o600 });
     await chmodPrivate(destination, 0o600);
     collection.entries.push(evidenceEntry({
         context: collection.context,
@@ -643,8 +663,11 @@ async function collectOneEvidenceFile(collection, options) {
         localPath: destination,
         relativePath,
         mediaType: options.mediaType,
-        redactedSummary: options.redactedSummary,
-        bytes: raw,
+        redactedSummary: redaction
+            ? `${options.redactedSummary} Secret-like values were deterministically redacted before upload.`
+            : options.redactedSummary,
+        redaction,
+        bytes: evidenceBytes,
         codexSessionId: options.sessionId,
         contentAddress: options.contentAddress(contentHash.slice(0, 16)),
     }));
@@ -664,6 +687,31 @@ function admitToBudget(budget, byteLength) {
     budget.remainingBytes -= byteLength;
     return null;
 }
+function sanitizeTextEvidenceForUpload(options) {
+    const originalBytes = options.originalBytes ?? Buffer.from(options.text, "utf8");
+    const redactionResult = redactSecretLikeContent(options.text, {
+        appliedBy: "local_collector",
+        redactedFields: options.redactedFields,
+    });
+    if (redactionResult.redacted) {
+        if (containsSecretLikeContent(redactionResult.text)) {
+            return { status: "blocked", reason: "secret_redaction_failed" };
+        }
+        const sanitizedBytes = Buffer.from(redactionResult.text, "utf8");
+        return {
+            status: "redacted",
+            bytes: sanitizedBytes,
+            redaction: withRedactionContentMetadata(redactionResult.metadata, {
+                originalBytes,
+                sanitizedBytes,
+            }),
+        };
+    }
+    if (containsSecretLikeContent(options.text)) {
+        return { status: "blocked", reason: "secret_like_content_guard" };
+    }
+    return { status: "clean", bytes: originalBytes };
+}
 async function collectGitDiffFiles(collection, repoRoot) {
     const diffTargets = [
         { label: "unstaged", args: ["diff", "--no-ext-diff", "--"] },
@@ -697,15 +745,27 @@ async function collectGitDiffFiles(collection, repoRoot) {
         }
         if (!diff.stdout.trim())
             continue;
-        if (containsSecretLikeContent(diff.stdout)) {
+        const sanitized = sanitizeTextEvidenceForUpload({
+            text: diff.stdout,
+            redactedFields: [`git_diff.${target.label}`],
+        });
+        if (sanitized.status === "blocked") {
             collection.skipped.push({
                 kind: "git_diff",
                 label: target.label,
-                reason: "secret_like_content_guard",
+                reason: sanitized.reason,
             });
             continue;
         }
-        const raw = Buffer.from(diff.stdout, "utf8");
+        if (sanitized.status === "redacted") {
+            collection.redacted.push({
+                kind: "git_diff",
+                label: target.label,
+                redaction: sanitized.redaction,
+            });
+        }
+        const raw = sanitized.bytes;
+        const redaction = sanitized.redaction;
         const contentHash = sha256(raw);
         if (collection.skipContentHashes.has(contentHash)) {
             collection.reused.push({
@@ -737,9 +797,12 @@ async function collectGitDiffFiles(collection, repoRoot) {
             localPath: destination,
             relativePath,
             mediaType: "text/x-diff",
-            redactedSummary: diff.truncated
-                ? `Raw git ${target.label} diff truncated to the capture cap and preserved locally with env/secret paths excluded.`
-                : `Raw git ${target.label} diff preserved locally with env/secret paths excluded.`,
+            redactedSummary: redaction
+                ? `Raw git ${target.label} diff preserved locally with env/secret paths excluded and secret-like values deterministically redacted.`
+                : diff.truncated
+                    ? `Raw git ${target.label} diff truncated to the capture cap and preserved locally with env/secret paths excluded.`
+                    : `Raw git ${target.label} diff preserved locally with env/secret paths excluded.`,
+            redaction,
             bytes: raw,
             contentAddress: `git-diff/${target.label}-${contentHash.slice(0, 16)}.diff`,
         }));
@@ -864,6 +927,8 @@ function makeEvidenceCompleteness(collection, options) {
         sources.add(entry.kind);
     for (const entry of collection.failed)
         sources.add(entry.kind);
+    for (const entry of collection.redacted)
+        sources.add(entry.kind);
     const sourceCounts = [...sources].sort().map((source) => {
         const skipped = collection.skipped.filter((entry) => entry.kind === source);
         return {
@@ -950,10 +1015,30 @@ function makeEvidenceCompleteness(collection, options) {
             });
         }
     }
+    const redactionCounts = new Map();
+    for (const redacted of collection.redacted) {
+        const ruleIds = redacted.redaction.rule_counts.map((rule) => rule.rule_id);
+        const key = `${redacted.kind}:${redacted.redaction.mode}:${ruleIds.sort().join(",")}`;
+        const existing = redactionCounts.get(key);
+        if (existing) {
+            existing.count += 1;
+            existing.rule_ids = [...new Set([...existing.rule_ids, ...ruleIds])].sort();
+        }
+        else {
+            redactionCounts.set(key, {
+                source: redacted.kind,
+                status: "sanitized",
+                mode: redacted.redaction.mode,
+                count: 1,
+                rule_ids: [...new Set(ruleIds)].sort(),
+            });
+        }
+    }
     const hasGaps = totals.skipped_count > 0 ||
         totals.truncated_count > 0 ||
         totals.deferred_count > 0 ||
         totals.failed_count > 0 ||
+        collection.redacted.length > 0 ||
         collection.caps.some((cap) => cap.applied);
     const status = totals.failed_count > 0 &&
         totals.included_count + totals.reused_count === 0
@@ -978,11 +1063,14 @@ function makeEvidenceCompleteness(collection, options) {
         skip_reasons: [...skipReasonCounts.values()].sort((a, b) => `${a.source}:${a.reason}`.localeCompare(`${b.source}:${b.reason}`)),
         failure_reasons: [...failureReasonCounts.values()].sort((a, b) => `${a.source}:${a.reason}`.localeCompare(`${b.source}:${b.reason}`)),
         truncation_markers: [...truncationCounts.values()].sort((a, b) => `${a.source}:${a.reason}`.localeCompare(`${b.source}:${b.reason}`)),
+        redaction_markers: [...redactionCounts.values()].sort((a, b) => `${a.source}:${a.mode}`.localeCompare(`${b.source}:${b.mode}`)),
         notes: totals.failed_count > 0
             ? ["Evidence collection failed; downstream analysis should not infer confidence."]
-            : hasGaps
-                ? ["Evidence is incomplete; downstream analysis should lower confidence."]
-                : [],
+            : collection.redacted.length > 0
+                ? ["Evidence was sanitized before upload; downstream analysis should not treat it as raw-complete."]
+                : hasGaps
+                    ? ["Evidence is incomplete; downstream analysis should lower confidence."]
+                    : [],
     });
 }
 async function walkJsonlFiles(dir, cutoffMs) {
@@ -1045,6 +1133,7 @@ function makeManifest(options) {
         },
         files: options.entries.map(redactManifestEntry),
         skipped: options.skipped,
+        redacted: options.redacted,
         reused: options.reused,
     };
 }
@@ -1065,6 +1154,7 @@ function evidenceEntry(options) {
         byte_size: options.bytes.byteLength,
         media_type: options.mediaType,
         redacted_summary: options.redactedSummary,
+        ...(options.redaction ? { redaction: options.redaction } : {}),
         codex_session_id: options.codexSessionId ?? null,
         ...(options.artifactMetadata
             ? {
@@ -1089,6 +1179,7 @@ function redactManifestEntry(entry) {
         byte_size: entry.byte_size,
         media_type: entry.media_type,
         redacted_summary: entry.redacted_summary,
+        ...(entry.redaction ? { redaction: entry.redaction } : {}),
         ...(entry.artifact_metadata
             ? { artifact_metadata: entry.artifact_metadata }
             : {}),
@@ -1109,6 +1200,7 @@ function pointerFromEntry(entry) {
         byte_size: entry.byte_size,
         media_type: entry.media_type,
         redacted_summary: entry.redacted_summary,
+        ...(entry.redaction ? { redaction: entry.redaction } : {}),
     };
 }
 /**
@@ -1193,6 +1285,18 @@ function safeKeySegment(value) {
 function sha256(value) {
     return crypto.createHash("sha256").update(value).digest("hex");
 }
+function withRedactionContentMetadata(metadata, options) {
+    if (!metadata) {
+        throw new Error("redacted evidence is missing redaction metadata");
+    }
+    return {
+        ...metadata,
+        original_content_hash_sha256: sha256(options.originalBytes),
+        sanitized_content_hash_sha256: sha256(options.sanitizedBytes),
+        original_byte_size: options.originalBytes.byteLength,
+        sanitized_byte_size: options.sanitizedBytes.byteLength,
+    };
+}
 async function ensurePrivateDir(dir) {
     await fs.mkdir(dir, { recursive: true, mode: 0o700 });
     await chmodPrivate(dir, 0o700);

package/dist/agent-rules.js

@@ -15,7 +15,11 @@ export async function installAgentRules(options = {}) {
 }
 async function installAgentRulesForHost(host, options = {}) {
     const rulesFile = agentRulesFile(host, options.homeDir);
-    const block = cockpitAgentRulesBlock({ scopePath: options.scopePath });
+    const block = cockpitAgentRulesBlock({
+        scopePath: options.scopePath,
+        scopePaths: options.scopePaths,
+    });
+    const scopePaths = normalizeScopePaths(options);
     let existing = "";
     let existed = true;
     try {
@@ -24,7 +28,7 @@ async function installAgentRulesForHost(host, options = {}) {
     catch {
         existed = false;
     }
-    const prepared = prepareManagedBlockInstall(existing, block, options.scopePath);
+    const prepared = prepareManagedBlockInstall(existing, block, scopePaths);
     if (!prepared.next) {
         return agentRulesResult(host, rulesFile, "unchanged", block, prepared.state);
     }
@@ -78,7 +82,11 @@ export async function inspectAgentRules(options = {}) {
 }
 async function inspectAgentRulesForHost(host, options = {}) {
     const rulesFile = agentRulesFile(host, options.homeDir);
-    const block = cockpitAgentRulesBlock({ scopePath: options.scopePath });
+    const block = cockpitAgentRulesBlock({
+        scopePath: options.scopePath,
+        scopePaths: options.scopePaths,
+    });
+    const scopePaths = normalizeScopePaths(options);
     let existing = "";
     try {
         existing = await readFile(rulesFile, "utf8");
@@ -89,7 +97,7 @@ async function inspectAgentRulesForHost(host, options = {}) {
             installed: false,
         };
     }
-    const state = inspectAgentRulesContents(existing, block, options.scopePath);
+    const state = inspectAgentRulesContents(existing, block, scopePaths);
     const installed = state === "managed" || state === "equivalent";
     return {
         ...agentRulesResult(host, rulesFile, installed ? "unchanged" : "missing", block, state),
@@ -97,23 +105,38 @@ async function inspectAgentRulesForHost(host, options = {}) {
     };
 }
 export function cockpitAgentRulesBlock(options = {}) {
-    const scopePath = options.scopePath ? path.resolve(options.scopePath) : null;
-    const scopeLine = scopePath
-        ? `- This guidance only applies when the current working directory is inside the Cockpit-onboarded workspace/repo: \`${scopePath}\`. Outside that folder, do not run Cockpit ticket binding or sync commands for private chats or unrelated repos.`
-        : "- This guidance only applies when the current working directory is inside the workspace/repo that ran `cockpit onboard` or `cockpit agent-rules install`. Outside that folder, do not run Cockpit ticket binding or sync commands for private chats or unrelated repos.";
+    const scopePaths = normalizeScopePaths(options);
+    const scopeLine = scopePaths.length === 1
+        ? `- This guidance only applies when the current working directory is inside the Cockpit-onboarded workspace/repo: \`${scopePaths[0]}\`. Outside that folder, do not run Cockpit ticket binding or sync commands for private chats or unrelated repos.`
+        : scopePaths.length > 1
+            ? `- This guidance only applies when the current working directory is inside one of these Cockpit-onboarded workspace roots: ${scopePaths.map((scopePath) => `\`${scopePath}\``).join(", ")}. Outside those folders, do not run Cockpit ticket binding or sync commands for private chats or unrelated repos.`
+            : "- This guidance only applies when the current working directory is inside the workspace/repo that ran `cockpit onboard` or `cockpit agent-rules install`. Outside that folder, do not run Cockpit ticket binding or sync commands for private chats or unrelated repos.";
     return [
         MANAGED_BLOCK_START,
         "## Cockpit Ticket Binding",
         "",
         scopeLine,
-        "- For implementation, debugging, review, PR, or ship work tied to a clear Linear ticket, run `cockpit start --ticket <ticket-id> --workspace \"$PWD\"` before the first code edit or mutating tool call. This starts attributing the session's work to that specific ticket in Cockpit.",
+        "- For implementation, debugging, review, PR, or ship work that already has a clear Linear ticket, run `cockpit start --ticket <ticket-id> --workspace \"$PWD\"` before the first code edit or mutating tool call. This starts attributing the session's work to that specific ticket in Cockpit.",
         "- Use `--ticket`; do not invent `--ticketId` or other flag shapes.",
-        "- If the user mentions ticketed work but no ticket ID is visible, ask once for the Linear ticket ID before editing. Agents cannot reliably infer it from context.",
+        "- If the user mentions ticketed work but no ticket ID is visible, search Linear for an existing ticket before editing. If none exists and the work is ticket-worthy, create a narrow Linear ticket, then run the canonical `cockpit start --ticket ...` command. Ask the user only when ticket creation would be ambiguous or the user has forbidden creating one.",
         "- If there is truly no ticket, state that the work remains in general ambient capture and do not invent a ticket.",
         "- After the first meaningful checkpoint, run `cockpit sync --workspace \"$PWD\" --json` so Cockpit has fresh ticket/session binding metadata.",
         MANAGED_BLOCK_END,
     ].join("\n");
 }
+function normalizeScopePaths(options) {
+    const raw = options.scopePaths ?? (options.scopePath ? [options.scopePath] : []);
+    const seen = new Set();
+    const normalized = [];
+    for (const scopePath of raw) {
+        const resolved = path.resolve(scopePath);
+        if (seen.has(resolved))
+            continue;
+        seen.add(resolved);
+        normalized.push(resolved);
+    }
+    return normalized;
+}
 export function hasManagedBlock(contents) {
     return contents.includes(MANAGED_BLOCK_START) && contents.includes(MANAGED_BLOCK_END);
 }
@@ -131,7 +154,7 @@ export function removeManagedBlock(contents) {
         return contents;
     return contents.replace(managedBlockPattern(), "").replace(/\n{3,}/gu, "\n\n").trimEnd() + "\n";
 }
-function prepareManagedBlockInstall(contents, block, scopePath) {
+function prepareManagedBlockInstall(contents, block, scopePaths = []) {
     if (!contents.trim())
         return { next: `${block}\n`, state: "missing" };
     if (hasManagedBlock(contents)) {
@@ -140,10 +163,10 @@ function prepareManagedBlockInstall(contents, block, scopePath) {
             state: extractManagedBlock(contents) === block ? "managed" : "stale",
         };
     }
-    if (hasEquivalentUnmanagedTicketBinding(contents, scopePath)) {
+    if (hasEquivalentUnmanagedTicketBinding(contents, scopePaths)) {
         return { next: null, state: "equivalent" };
     }
-    const staleBlock = findStaleUnmanagedTicketBindingBlock(contents, scopePath);
+    const staleBlock = findStaleUnmanagedTicketBindingBlock(contents, scopePaths);
     if (staleBlock) {
         return {
             next: replaceLineSpan(contents, staleBlock.startLine, staleBlock.endLine, block),
@@ -152,13 +175,13 @@ function prepareManagedBlockInstall(contents, block, scopePath) {
     }
     return { next: `${contents.replace(/\s+$/u, "")}\n\n${block}\n`, state: "missing" };
 }
-function inspectAgentRulesContents(contents, block, scopePath) {
+function inspectAgentRulesContents(contents, block, scopePaths = []) {
     if (hasManagedBlock(contents)) {
         return extractManagedBlock(contents) === block ? "managed" : "stale";
     }
-    if (hasEquivalentUnmanagedTicketBinding(contents, scopePath))
+    if (hasEquivalentUnmanagedTicketBinding(contents, scopePaths))
         return "equivalent";
-    if (findStaleUnmanagedTicketBindingBlock(contents, scopePath))
+    if (findStaleUnmanagedTicketBindingBlock(contents, scopePaths))
         return "stale";
     return "missing";
 }
@@ -200,24 +223,28 @@ function managedBlockPattern() {
 function extractManagedBlock(contents) {
     return contents.match(managedBlockPattern())?.[0] ?? null;
 }
-function hasEquivalentUnmanagedTicketBinding(contents, scopePath) {
+function hasEquivalentUnmanagedTicketBinding(contents, scopePaths = []) {
     const text = normalizeRuleText(contents);
     if (!hasTicketBindingCues(text))
         return false;
     if (!hasRepoScopeGuard(text))
         return false;
-    if (scopePath && !hasScopePath(text, scopePath))
+    if (scopePaths.some((scopePath) => !hasScopePath(text, scopePath)))
+        return false;
+    if (!hasTicketLookupOrCreationCue(text))
         return false;
     const signals = [
         /cockpit\s+start\s+--ticket\b/u,
         /before\s+(?:the\s+)?first\s+code\s+edit|before\s+ticketed\s+implementation/u,
-        /ticket\s+id\s+(?:is\s+)?(?:missing|visible)|ask\s+once/u,
         /general\s+ambient/u,
         /cockpit\s+sync\s+--repo|fresh\s+ticket\/session\s+binding\s+metadata/u,
         /use\s+--ticket|do\s+not\s+invent\s+--ticketid/u,
     ];
     const score = signals.filter((signal) => signal.test(text)).length;
-    return score >= 5;
+    return score >= 4;
+}
+function hasTicketLookupOrCreationCue(text) {
+    return /search\s+linear|create\s+(?:a\s+)?(?:narrow\s+)?linear\s+ticket|new\s+linear\s+ticket/u.test(text);
 }
 function hasScopePath(text, scopePath) {
     return text.includes(normalizeRuleText(path.resolve(scopePath)));
@@ -227,7 +254,7 @@ function hasRepoScopeGuard(text) {
         /outside\s+that\s+(?:folder|workspace|repo).*(?:do\s+not|dont)\s+run\s+cockpit/u.test(text) ||
         /private\s+chats\s+or\s+unrelated\s+repos/u.test(text));
 }
-function findStaleUnmanagedTicketBindingBlock(contents, scopePath) {
+function findStaleUnmanagedTicketBindingBlock(contents, scopePaths = []) {
     const lines = contents.split("\n");
     for (let index = 0; index < lines.length; index += 1) {
         if (!/^#{1,6}\s+.*(?:cockpit\s+)?ticket\s+binding\b/iu.test(lines[index] ?? "")) {
@@ -243,7 +270,7 @@ function findStaleUnmanagedTicketBindingBlock(contents, scopePath) {
         const candidate = lines.slice(index, endLine).join("\n");
         const normalized = normalizeRuleText(candidate);
         if (hasTicketBindingCues(normalized) &&
-            !hasEquivalentUnmanagedTicketBinding(candidate, scopePath)) {
+            !hasEquivalentUnmanagedTicketBinding(candidate, scopePaths)) {
             return { startLine: index, endLine };
         }
     }

package/dist/autostart.js

@@ -29,7 +29,9 @@ export async function installAutostartAgent(options) {
     if (platform !== "darwin")
         return unsupportedResult(options.homeDir);
     const homeDir = options.homeDir ?? os.homedir();
-    const workDir = path.resolve(options.repoRoot ?? process.cwd());
+    const workDirs = normalizeWorkDirs(options.repoRoots);
+    const workDir = path.resolve(options.repoRoot ?? workDirs[0] ?? process.cwd());
+    const resolvedWorkDirs = workDirs.length > 0 ? workDirs : [workDir];
     const dashboardUrl = options.dashboardUrl ?? DEFAULT_DASHBOARD_URL;
     const intervalSeconds = options.intervalSeconds ?? DEFAULT_AUTOSTART_INTERVAL_SECONDS;
     const paths = getCollectorRuntimePaths(homeDir);
@@ -44,6 +46,7 @@ export async function installAutostartAgent(options) {
     await mkdir(paths.state_dir, { recursive: true });
     await writeFile(plistPath, renderPlist({
         workDir,
+        workDirs: resolvedWorkDirs,
         dashboardUrl,
         intervalSeconds,
         stdoutPath,
@@ -62,6 +65,7 @@ export async function installAutostartAgent(options) {
         loaded,
         interval_seconds: intervalSeconds,
         work_dir: workDir,
+        work_dirs: resolvedWorkDirs,
         dashboard_url: dashboardUrl,
         ...(loaded
             ? {}
@@ -131,7 +135,10 @@ function renderPlist(options) {
     const dashboardArg = options.dashboardUrl === DEFAULT_DASHBOARD_URL
         ? ""
         : ` --dashboard-url ${shellQuote(options.dashboardUrl)}`;
-    const command = `cockpit sync --workspace ${shellQuote(options.workDir)}${dashboardArg} --json`;
+    const roots = options.workDirs.length > 0 ? options.workDirs : [options.workDir];
+    const command = roots
+        .map((root) => `cockpit sync --workspace ${shellQuote(root)}${dashboardArg} --json`)
+        .join("; ");
     return [
         '<?xml version="1.0" encoding="UTF-8"?>',
         '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
@@ -169,6 +176,20 @@ function renderPlist(options) {
         "",
     ].join("\n");
 }
+function normalizeWorkDirs(repoRoots) {
+    if (!repoRoots)
+        return [];
+    const seen = new Set();
+    const normalized = [];
+    for (const root of repoRoots) {
+        const resolved = path.resolve(root);
+        if (seen.has(resolved))
+            continue;
+        seen.add(resolved);
+        normalized.push(resolved);
+    }
+    return normalized;
+}
 /**
  * Renders the `<key>WatchPaths</key><array>…</array>` lines, or nothing when no
  * transcript dir exists yet (an empty array would tell launchd to watch