@bli-cockpit/cli 0.2.7 → 0.2.9

package/README.md

@@ -64,7 +64,7 @@ families before its exact version is promoted to npm `latest`.
 | `cockpit sync` | Captures and uploads once, right now. This is what the background agent runs every 15 min — you almost never type it yourself. | Named for what it does: synchronize local session files up to the dashboard. |
 | `cockpit analyze` | Runs a fresh sync, then queues batch analysis of your latest uploaded sessions. It returns immediately; status and results appear in My Work. | One command when you want newly finished work uploaded and judged now. |
 | `cockpit start --ticket <id>` | Tags your CURRENT work with a Linear ticket so sessions attribute to it. `--clear-ticket` returns to general capture. | "Start (working on) X." Agents usually run this for you per the agent rules. |
-| `cockpit login` / `cockpit pair` | Just the sign-in + device-registration step, standalone (onboard already includes it). Two names, one command: `login` is what humans guess, `pair` is what the dashboard's device screen calls it. | Recovery path when a session expires or you switch accounts. |
+| `cockpit login` / `cockpit pair` | Just the sign-in + device-registration step, standalone (onboard already includes it). Works on a fresh machine too: it writes a minimal local config first (no collection roots — run `cockpit onboard` afterwards to register those). Two names, one command: `login` is what humans guess, `pair` is what the dashboard's device screen calls it. | Recovery path when a session expires or you switch accounts, or sign-in first on a brand-new machine. |
 | `cockpit logout` | Deletes this machine's session. | The undo of login. |
 | `cockpit update` / `cockpit upgrade` | Updates the CLI itself from npm, then reruns onboard. Two names, one command — aliases because half of people guess each. | Self-update; run when Edward announces a new version. |
 | `cockpit install` | Writes local config only (step 1 of onboard, standalone). | Plumbing; exists so onboard's pieces are individually runnable. You'll likely never type it. |

package/dist/agent-rules.js

@@ -107,20 +107,25 @@ async function inspectAgentRulesForHost(host, options = {}) {
 export function cockpitAgentRulesBlock(options = {}) {
     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.`
+        ? `- 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.";
+            ? `- 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.`
+            : "- 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 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, 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.",
+        "- Ticketed work (implement / debug / review / PR / ship): run `cockpit start --ticket <ticket-id> --workspace \"$PWD\"` before the first code edit (the flag is `--ticket`). No ticket ID visible → search Linear first; none exists and the work is ticket-worthy → create a narrow Linear ticket, then bind.",
+        "- Truly no ticket → say the session stays in general ambient capture; never invent one.",
+        "- After the first meaningful checkpoint, run `cockpit sync --workspace \"$PWD\" --json`.",
+        "",
+        "## Definition of done — QA receipts",
+        "",
+        "- A change a user can see or click is NOT done until a computer-use QA pass has exercised it and left receipts (screenshots or logs of the actual run). Green CI alone does not close a user-visible change.",
+        "- Computer use first, always. The human can take over the browser at any point; when that happens, stop driving, observe, and record what the human verified.",
+        "- A reviewer or QA agent spawned by the builder does not count as independent verification by itself — the receipt is what counts, not the reviewer's opinion.",
+        "- QA catches the cheap majority of bugs, not all of them. Do the pass, attach the receipts, ship; remaining bugs get fixed as normal bugs.",
         MANAGED_BLOCK_END,
     ].join("\n");
 }
@@ -233,16 +238,25 @@ function hasEquivalentUnmanagedTicketBinding(contents, scopePaths = []) {
         return false;
     if (!hasTicketLookupOrCreationCue(text))
         return false;
+    // Contents without the QA-receipts rule are the older vocabulary and must
+    // read as stale — otherwise machines with a hand-written ticket-binding
+    // section never receive the definition-of-done rule.
+    if (!hasQaReceiptsCue(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,
         /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,
+        /cockpit\s+sync\s+--repo|cockpit\s+sync\s+--workspace|fresh\s+ticket\/session\s+binding\s+metadata/u,
+        /use\s+--ticket|the\s+flag\s+is\s+--ticket|do\s+not\s+invent\s+--ticketid/u,
     ];
     const score = signals.filter((signal) => signal.test(text)).length;
     return score >= 4;
 }
+function hasQaReceiptsCue(text) {
+    return /computer-use\s+qa\s+pass/u.test(text)
+        && /receipts/u.test(text);
+}
 function hasTicketLookupOrCreationCue(text) {
     return /search\s+linear|create\s+(?:a\s+)?(?:narrow\s+)?linear\s+ticket|new\s+linear\s+ticket/u.test(text);
 }

package/dist/commands/local.js

@@ -9,7 +9,7 @@ import { runDoctor } from "./doctor.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, LOCAL_COLLECTOR_VERSION, readLocalCollectorConfig, readLocalCollectorSessionFile, readLocalSessionReference, startLocalWorkContext, } from "../local-state.js";
+import { DEFAULT_DASHBOARD_URL, ensureLocalCollectorConfig, getCollectorRuntimePaths, inspectLocalCollectorStatus, installLocalCollector, logoutLocalCollector, pairLocalCollector, LOCAL_COLLECTOR_VERSION, readLocalCollectorConfig, readLocalCollectorSessionFile, readLocalSessionReference, startLocalWorkContext, } from "../local-state.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 { backfillCompletionCovers, emptyBackfillCursorState, prepareBackfillCursorForScope, readBackfillCompletionMarker, readBackfillCursor, } from "../cursors/backfill-cursor.js";
@@ -855,7 +855,7 @@ const OTP_INVALID_MESSAGE = [
     "  Cockpit expects digits only, length 6 to 10.",
     "What you can do:",
     "  1) Rerun and paste the latest email code.",
-    "  2) Use manual approval: cockpit onboard --no-auth --email <you@buildlaunchiterate.ca>",
+    "  2) Use manual approval: rerun this command with --no-auth --email <you@buildlaunchiterate.ca>",
 ].join("\n");
 async function resolveOnboardEmail(command, roots, config, io) {
     if (command.claimedOwnerEmail)
@@ -1774,8 +1774,18 @@ function worktreeSyncRow(outcome, run) {
     };
 }
 async function runLogin(command, io) {
+    // Standalone `cockpit login` must work on a fresh machine: bootstrap a
+    // minimal rootless config when onboard/install has not run yet, instead of
+    // failing on the missing config file.
+    const { config, paths, created } = await ensureLocalCollectorConfig({
+        homeDir: command.homeDir,
+        dashboardUrl: command.dashboardUrl,
+    });
+    const dashboardUrl = command.dashboardUrl ?? config.dashboard_url;
+    if (created && !command.json) {
+        writeLine(io.stdout, `First login on this machine; wrote collector config: ${paths.config_file}`);
+    }
     const claimedOwnerEmail = await resolveInteractiveLoginEmail(command, io);
-    const dashboardUrl = await resolveLoginDashboardUrl(command);
     const pairingAccessToken = await requestPairingAccessToken({
         dashboardUrl,
         email: claimedOwnerEmail,
@@ -1784,7 +1794,7 @@ async function runLogin(command, io) {
     }, io);
     const result = await pairLocalCollectorWithAuthFallback({
         homeDir: command.homeDir,
-        dashboardUrl: command.dashboardUrl,
+        dashboardUrl,
         claimedOwnerEmail,
         deviceName: command.deviceName,
         pollIntervalMs: command.pollIntervalMs,
@@ -1808,16 +1818,11 @@ async function runLogin(command, io) {
     writeLine(io.stdout, `Session: ${result.session_file}`);
     writeLine(io.stdout, `User: ${result.session.email ?? result.session.auth_subject_id}`);
     writeLine(io.stdout, `Device: ${result.session.device_name ?? result.session.device_id ?? "unknown"}`);
-    writeLine(io.stdout, "Next: run `cockpit start` inside the repo.");
+    writeLine(io.stdout, config.default_repo_paths.length > 0
+        ? "Next: run `cockpit start` inside the repo."
+        : "Next: run `cockpit onboard` from your repo root so Cockpit knows which repos to collect.");
     return 0;
 }
-async function resolveLoginDashboardUrl(command) {
-    if (command.dashboardUrl)
-        return command.dashboardUrl;
-    const paths = getCollectorRuntimePaths(command.homeDir);
-    const config = await readLocalCollectorConfig(paths);
-    return config.dashboard_url;
-}
 function writePairingInstructions(io, request) {
     writeLine(io.stdout, "2/5 Device pairing started.");
     writeLine(io.stdout, `Open: ${request.approve_url}`);

package/dist/commands/public-root.js

@@ -8,7 +8,7 @@ export async function runCockpitCli(argv, io) {
   }
 
   if (command === "--version" || command === "-V" || command === "version") {
-    writeLine(io?.stdout ?? process.stdout, "0.2.7");
+    writeLine(io?.stdout ?? process.stdout, "0.2.9");
     return 0;
   }
 

package/dist/local-state.js

@@ -74,12 +74,48 @@ function normalizeRepoRoots(repoRoots) {
     }
     return normalizeCollectionRoots(candidates);
 }
+/**
+ * Reads the collector config, creating a minimal rootless one when the file
+ * does not exist yet (fresh machine where `cockpit onboard`/`install` has not
+ * run). Never registers collection roots: root consent stays with
+ * onboard/install. A corrupt existing config is never overwritten.
+ */
+export async function ensureLocalCollectorConfig(options = {}) {
+    const homeDir = options.homeDir ?? os.homedir();
+    const paths = getCollectorRuntimePaths(homeDir);
+    await ensureRuntimeDirectories(paths);
+    let existing = null;
+    try {
+        existing = await readLocalCollectorConfig(paths);
+    }
+    catch (error) {
+        if (!isMissingFileError(error)) {
+            const reason = error instanceof Error ? error.message : String(error);
+            throw new Error(`Local collector config at ${paths.config_file} is unreadable (${reason}). ` +
+                "Run `cockpit onboard` to repair it.");
+        }
+    }
+    if (existing)
+        return { config: existing, paths, created: false };
+    const config = LocalCollectorConfigSchema.parse({
+        schema_version: "telemetry-core.v1",
+        dashboard_url: normalizeDashboardUrl(options.dashboardUrl ?? DEFAULT_DASHBOARD_URL),
+        collector_version: LOCAL_COLLECTOR_VERSION,
+        device_id: `device-${crypto.randomUUID()}`,
+        device_name: defaultDeviceName(),
+        default_repo_paths: [],
+        session_file_path: paths.session_file,
+        state_dir_path: paths.state_dir,
+    });
+    await writeJsonFile(paths.config_file, config);
+    return { config, paths, created: true };
+}
 export async function pairLocalCollector(options = {}) {
     const homeDir = options.homeDir ?? os.homedir();
     const paths = getCollectorRuntimePaths(homeDir);
     await ensureRuntimeDirectories(paths);
     const config = await readLocalCollectorConfig(paths).catch(() => {
-        throw new Error("Local config missing. Run `cockpit install` before `cockpit login`.");
+        throw new Error("Local config missing. Run `cockpit onboard` (or `cockpit install`) first, then retry `cockpit login`.");
     });
     const dashboardUrl = normalizeDashboardUrl(options.dashboardUrl ?? config.dashboard_url);
     const deviceId = config.device_id ?? `device-${crypto.randomUUID()}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "private": false,
   "type": "module",
   "bin": {
@@ -26,6 +26,6 @@
     "test": "node dist/cli.js --help && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/telemetry-core": "0.1.13"
+    "@bli-cockpit/telemetry-core": "0.1.15"
   }
 }