@bli-cockpit/cli 0.2.126 → 0.2.128

package/dist/commands/local-args-tower-memory.js

@@ -44,6 +44,7 @@ const ALLOWED_FLAGS = [
     "--limit",
     "--no-recent",
     "--custom-id",
+    "--alias",
     "--extract",
     "--file",
     "--content-stdin",
@@ -58,6 +59,7 @@ const VALUE_FLAGS = [
     "--container",
     "--limit",
     "--custom-id",
+    "--alias",
     "--file",
     "--reason",
 ];
@@ -71,6 +73,9 @@ export function parseMemoryStoreArgs(action, args) {
     if (action !== "search" && (values.flags.has("--limit") || values.booleans.has("--no-recent"))) {
         throw new Error("--limit and --no-recent only apply to memory search.");
     }
+    if (action !== "save" && values.flags.has("--alias")) {
+        throw new Error("--alias only applies to memory save.");
+    }
     if (action !== "save" && (values.flags.has("--custom-id") || values.booleans.has("--extract"))) {
         throw new Error("--custom-id and --extract only apply to memory save.");
     }
@@ -108,6 +113,7 @@ export function parseMemoryStoreArgs(action, args) {
             ...command,
             action,
             customId: optionalNonEmpty(values.flags.get("--custom-id")),
+            ...(values.flagValues.has("--alias") ? { aliases: values.flagValues.get("--alias") } : {}),
             extract: values.booleans.has("--extract"),
             filePath: optionalNonEmpty(values.flags.get("--file")),
         };

package/dist/commands/local-args-tower-settings.js

@@ -24,6 +24,7 @@ export function parseSettingsArgs(args) {
             "--brief-model",
             "--chat",
             "--memory",
+            "--note-reader",
             "--project",
             "--file",
             "--id",
@@ -37,6 +38,7 @@ export function parseSettingsArgs(args) {
             "--brief-model",
             "--chat",
             "--memory",
+            "--note-reader",
             "--project",
             "--file",
             "--id",
@@ -124,18 +126,21 @@ function parseCliFloorSection(rest, common) {
     }
     return { kind: "settings", section: "cli-floor", action: "set", floorVersion: version, ...common };
 }
-/** `settings models` or `settings models set --chat <key> / --memory <id>`. */
+/** `settings models` or `settings models set --chat <key> / --memory <id> / --note-reader <id>`. */
 function parseModelsSection(rest, flags, common) {
     if (rest.length === 0) {
         return { kind: "settings", section: "models", action: "show", ...common };
     }
     if (rest[0] !== "set" || rest.length > 1) {
-        throw new Error("settings models takes no verb, or `set --chat <key>` / `set --memory <id>`.");
+        throw new Error("settings models takes no verb, or `set --chat <key>` / `set --memory <id>` / `set --note-reader <id>`.");
     }
     const orgChatModel = optionalNonEmpty(flags.get("--chat"));
     const orgMemoryModel = optionalNonEmpty(flags.get("--memory"));
-    if (!orgChatModel && !orgMemoryModel) {
-        throw new Error("settings models set needs --chat <key>, --memory <id>, or both.");
+    // BLI-4484: the note reader is the third org-wide slot; the web page could
+    // set it since BLI-4045 and the CLI could not, which is the twin rule broken.
+    const orgNoteReaderModel = optionalNonEmpty(flags.get("--note-reader"));
+    if (!orgChatModel && !orgMemoryModel && !orgNoteReaderModel) {
+        throw new Error("settings models set needs --chat <key>, --memory <id>, --note-reader <id>, or any of them.");
     }
     return {
         kind: "settings",
@@ -143,6 +148,7 @@ function parseModelsSection(rest, flags, common) {
         action: "set",
         orgChatModel,
         orgMemoryModel,
+        orgNoteReaderModel,
         ...common,
     };
 }

package/dist/commands/local-discovery.js

@@ -1,37 +1,15 @@
 import { writeLine } from "./cli-io.js";
 import { resolveDiscoveryLimits, saveDiscoveryLimits, } from "../discovery-limits.js";
+import { getCollectorRuntimePaths, readLocalCollectorConfig, } from "../local-state.js";
 import { discoverGitWorktreesInRootsWithStatus, } from "../repo-identity.js";
 export async function discoverCommandWorktrees(repoRoot, discovery = {}, io) {
     // What the operator typed this run, else what they typed some previous run,
     // else the built-in defaults (BLI-2362).
     const limits = await resolveDiscoveryLimits(discovery, discovery.homeDir);
-    const maxWorktrees = limits.maxRepos;
-    const roots = Array.isArray(repoRoot)
-        ? repoRoot
-        : [repoRoot ?? process.cwd()];
-    const result = await discoverGitWorktreesInRootsWithStatus(roots, {
-        maxDepth: limits.maxDepth,
-        maxWorktrees,
-    });
-    if (io && result.unreadable_dirs.length > 0) {
-        // Never silently dropped: anything under these folders is missing from the
-        // scan, so say so even when the run otherwise succeeds.
-        writeLine(io.stderr, unreadableDirectoriesMessage(result.unreadable_dirs));
-    }
+    const askedForRoots = repoRoot === undefined ? undefined : Array.isArray(repoRoot) ? repoRoot : [repoRoot];
+    const roots = askedForRoots ?? [process.cwd()];
+    const result = await scanRootsReportingWhatItMissed(roots, limits, discovery, io);
     const worktrees = result.worktrees;
-    if (!result.complete) {
-        const message = incompleteDiscoveryMessage({
-            result,
-            roots,
-            maxDepth: limits.maxDepth,
-            maxRepos: maxWorktrees,
-            found: worktrees.length,
-        });
-        if (io)
-            writeLine(io.stderr, message);
-        discovery.onPartial?.(message);
-        console.error("[local-discovery] partial collection", JSON.stringify({ reason: result.incomplete_reasons.join(","), roots: roots.length, incomplete_roots: result.incomplete_roots.length, max_depth: limits.maxDepth, found: worktrees.length }));
-    }
     if (worktrees.length === 0 && result.complete && !discovery.allowEmpty) {
         // "No git repos found" is only true when the scan could actually SEE
         // everywhere it looked. With unreadable folders in hand, the sentence sent
@@ -53,10 +31,86 @@ export async function discoverCommandWorktrees(repoRoot, discovery = {}, io) {
                 "Fix the permissions on those folders and run the command again, or point --workspace at the project folders you can read.",
             ].join("\n"));
         }
+        // An explicit --workspace is an instruction about WHERE to look, so an
+        // empty answer there is the answer. Without one, the folder the operator
+        // stood in was a guess, and this machine already knows a better one — for
+        // the commands that asked for it (BLI-4467).
+        if (askedForRoots === undefined && discovery.fallbackToSavedRoots) {
+            return await discoverInSavedCollectionRoots(limits, discovery, io);
+        }
         throw new Error("No git repos found. Run from a git repo, or from a parent folder containing git repos.");
     }
     return worktrees;
 }
+/**
+ * The second look: this machine's approved collection roots, scanned with the
+ * same limits and the same partial/unreadable reporting as the first. Refuses
+ * only when there are no approved roots to read, because then the machine
+ * genuinely has nothing to point the operator at (BLI-4467).
+ */
+async function discoverInSavedCollectionRoots(limits, discovery, io) {
+    const savedRoots = await readSavedCollectionRoots(discovery.homeDir);
+    if (savedRoots.length === 0) {
+        console.error("[local-discovery] cwd holds no repos and this machine has no saved collection roots", JSON.stringify({ reason: "no_saved_roots" }));
+        throw new Error([
+            "No git repos found here and this machine has no approved collection roots.",
+            "Run `cockpit doctor` to set them up, or `cockpit roots add <dir>`.",
+        ].join("\n"));
+    }
+    console.error("[local-discovery] cwd holds no repos, using the saved collection roots", JSON.stringify({ reason: "roots_fallback", roots: savedRoots.length }));
+    if (io)
+        writeLine(io.stderr, "No git repo here; reading the machine's approved roots.");
+    const result = await scanRootsReportingWhatItMissed(savedRoots, limits, discovery, io);
+    console.error("[local-discovery] saved collection roots scanned", JSON.stringify({
+        reason: "roots_fallback_result",
+        roots: savedRoots.length,
+        found: result.worktrees.length,
+        complete: result.complete,
+    }));
+    return result.worktrees;
+}
+/** The approved roots this machine already agreed to collect, or none if the config cannot be read. */
+async function readSavedCollectionRoots(homeDir) {
+    const paths = getCollectorRuntimePaths(homeDir);
+    const config = await readLocalCollectorConfig(paths).catch((error) => {
+        console.error("[local-discovery] could not read the saved collection roots", JSON.stringify({
+            reason: error.code ?? "config_unreadable",
+        }));
+        return null;
+    });
+    return config?.default_repo_paths ?? [];
+}
+/**
+ * One scan plus the two things a scan owes the operator: the folders it could
+ * not open, and the coverage it could not finish. Shared so the fallback scan
+ * reports exactly what the first one does.
+ */
+async function scanRootsReportingWhatItMissed(roots, limits, discovery, io) {
+    const maxWorktrees = limits.maxRepos;
+    const result = await discoverGitWorktreesInRootsWithStatus(roots, {
+        maxDepth: limits.maxDepth,
+        maxWorktrees,
+    });
+    if (io && result.unreadable_dirs.length > 0) {
+        // Never silently dropped: anything under these folders is missing from the
+        // scan, so say so even when the run otherwise succeeds.
+        writeLine(io.stderr, unreadableDirectoriesMessage(result.unreadable_dirs));
+    }
+    if (!result.complete) {
+        const message = incompleteDiscoveryMessage({
+            result,
+            roots,
+            maxDepth: limits.maxDepth,
+            maxRepos: maxWorktrees,
+            found: result.worktrees.length,
+        });
+        if (io)
+            writeLine(io.stderr, message);
+        discovery.onPartial?.(message);
+        console.error("[local-discovery] partial collection", JSON.stringify({ reason: result.incomplete_reasons.join(","), roots: roots.length, incomplete_roots: result.incomplete_roots.length, max_depth: limits.maxDepth, found: result.worktrees.length }));
+    }
+    return result;
+}
 /**
  * Persists `--max-depth` / `--max-repos` when a command carried them, so the
  * number survives into the background sync and the doctor's own sync — neither

package/dist/commands/local-help-commands.js

@@ -156,7 +156,7 @@ export function localSubcommandHelp(command) {
                 "      Your teams and your two model choices. No flags = show.",
                 "  cockpit settings switches [set <key> <value>]",
                 "      Access and feature switches. Everyone may look; only an admin may set.",
-                "  cockpit settings models [set --chat <key>] [--memory <id>]",
+                "  cockpit settings models [set --chat <key>] [--memory <id>] [--note-reader <id>]",
                 "      The ORG-WIDE model map. Admin only, in both directions.",
                 "  cockpit settings cli-floor [<version>]",
                 "      The fleet forced-update floor: every collector below it updates on its",

package/dist/commands/memory-install-skills.js

@@ -67,6 +67,7 @@ const SAVE_MD = `# save_memory
 
 \`\`\`
 in : { content: string (1-200000, required),
+       aliases?: string[] (up to 16 alternate names of 64 characters),
        containerTag?: string,
        customId?: string,       // e.g. the session id — the upsert key
        metadata?: object }

package/dist/commands/memory-store.js

@@ -100,6 +100,7 @@ export function runMemoryVerbList(io, json) {
         "The experience log:",
         "  cockpit memory log <win|loss|noise> --store <bli|supermemory|both> \"<reason>\"",
         "",
+        "Save accepts repeated --alias names (up to 16 names of 64 characters).",
         "Omit --container and this repository's own memory space is used — the same",
         "space the bli-memory MCP server and its hooks read and write.",
     ]) {
@@ -184,6 +185,7 @@ async function saveMemory(command, door) {
         timeoutMs: WRITE_DEADLINE_MS,
         body: {
             content: body.text,
+            ...(command.aliases === undefined ? {} : { aliases: command.aliases }),
             containerTag,
             ...(command.customId ? { customId: command.customId } : {}),
             mode: command.extract ? "extract" : "verbatim",

package/dist/commands/public-root.js

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

package/dist/commands/sessions.js

@@ -19,7 +19,14 @@ const SESSION_SCAN_OVERRIDE_LIMIT = 10_000;
 export 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, homeDir: command.homeDir }, io);
+    const worktrees = await discoverCommandWorktrees(command.repoRoot, {
+        maxDepth: command.maxDepth,
+        maxRepos: command.maxRepos,
+        homeDir: command.homeDir,
+        // BLI-4467: a read-only question about what this machine has observed,
+        // so the approved roots answer it from any folder.
+        fallbackToSavedRoots: true,
+    }, io);
     const window = await sessionsScanWindow(command, now);
     const { codex, claude } = await scanSessionSources(command, homeDir, worktrees, now, window);
     const { codexRows, claudeRows } = sessionRows(codex, claude);

package/dist/commands/settings.js

@@ -187,6 +187,7 @@ async function setModels(command, tower, io) {
         body: {
             ...(command.orgChatModel ? { chatModel: parseModelKey(command.orgChatModel) } : {}),
             ...(command.orgMemoryModel ? { memoryModel: command.orgMemoryModel } : {}),
+            ...(command.orgNoteReaderModel ? { noteReaderModel: command.orgNoteReaderModel } : {}),
         },
     });
     if (!result.ok)

package/dist/commands/status.js

@@ -30,11 +30,26 @@ import { normalizeCollectionRoots } from "../root-normalization.js";
 export async function runStatus(command, io) {
     const backfillCursor = await inspectBackfillCursor(command.homeDir);
     const setupReceipt = await readMachineSetupReceipt(command.homeDir, io);
-    const worktrees = await discoverCommandWorktrees(command.repoRoot, { maxDepth: command.maxDepth, maxRepos: command.maxRepos, homeDir: command.homeDir }, io);
+    const worktrees = await discoverCommandWorktrees(command.repoRoot, {
+        maxDepth: command.maxDepth,
+        maxRepos: command.maxRepos,
+        homeDir: command.homeDir,
+        // BLI-4467: this command answers "what does this machine believe about
+        // itself", so standing in a folder with no repo is not a reason to
+        // refuse — the approved roots are the better answer.
+        fallbackToSavedRoots: true,
+    }, io);
     if (worktrees.length > 1) {
         return writeMultiRepoStatus(command, io, backfillCursor, setupReceipt, worktrees);
     }
-    return writeSingleRepoStatus(command, io, backfillCursor, setupReceipt);
+    // BLI-4467: with no --workspace, the folder was a guess and discovery is the
+    // one that knows which worktree this is about — the fallback above may have
+    // found it under an approved root, nowhere near the cwd. Describing the guess
+    // printed `repo: <the empty folder>` and `branch: unknown` while exiting 0.
+    const single = command.repoRoot === undefined && worktrees.length === 1
+        ? { ...command, repoRoot: worktrees[0].repo_root }
+        : command;
+    return writeSingleRepoStatus(single, io, backfillCursor, setupReceipt);
 }
 async function readMachineSetupReceipt(homeDir, io) {
     // BLI-3731: "is this machine actually connected?" belongs beside "is it

package/dist/upload-agent-artifacts.js

@@ -40,20 +40,26 @@ export async function reportAgentImageArtifacts(options) {
         // Both non-2xx branches returned a label and said nothing (BLI-3483). An
         // image that never gets reported is never redacted and never OCR'd, and
         // the only place that fact existed was a return value the sync discards.
-        if (response.status === 404) {
-            console.error("[agent-artifacts] the dashboard has no agent-artifact route; these images stay unreported", JSON.stringify({
-                reason: "agent_artifact_api_unavailable",
-                http_status: 404,
-                artifact_count: artifacts.length,
-            }));
-            return {
-                posted: false,
-                reason: "agent_artifact_api_unavailable",
-                recorded_count: 0,
-            };
-        }
         if (!response.ok) {
-            const serverReason = serverFailureDetail(await readResponseJson(response));
+            const errorBody = await readResponseJson(response);
+            // A 404 is two different facts. "No such route" is the platform
+            // answering with an empty or HTML body; a JSON error envelope means the
+            // route answered and refused, and calling that "the dashboard has no
+            // agent-artifact route" hid a real refusal behind a shrug for as long as
+            // the door rejected ambient tickets.
+            if (response.status === 404 && !routeAnswered(errorBody)) {
+                console.error("[agent-artifacts] nothing answered at the agent-artifact path; these images stay unreported", JSON.stringify({
+                    reason: "agent_artifact_api_unavailable",
+                    http_status: 404,
+                    artifact_count: artifacts.length,
+                }));
+                return {
+                    posted: false,
+                    reason: "agent_artifact_api_unavailable",
+                    recorded_count: 0,
+                };
+            }
+            const serverReason = serverFailureDetail(errorBody);
             console.error("[agent-artifacts] report refused", JSON.stringify({
                 reason: "report_failed",
                 http_status: response.status,
@@ -99,6 +105,20 @@ export async function reportAgentImageArtifacts(options) {
         return { posted: false, reason: "report_network_error", recorded_count: 0 };
     }
 }
+/**
+ * Did the route answer, or did something in front of it?
+ *
+ * The dashboard's refusals are always a JSON envelope carrying a `code` (and
+ * sometimes a `reason`); a missing route answers with an empty body or a
+ * platform HTML page, which `readResponseJson` hands back as `{ message }`.
+ * That difference is the whole reason a 404 can mean two things.
+ */
+function routeAnswered(body) {
+    if (!body || typeof body !== "object")
+        return false;
+    const record = body;
+    return (typeof record["code"] === "string" || typeof record["reason"] === "string");
+}
 /**
  * The images this sync made durable, from both directions.
  *

package/dist/upload-http.js

@@ -39,11 +39,19 @@ export async function readResponseJson(response) {
  * The server's own reason for refusing, as something safe to log.
  *
  * The dashboard's error envelopes answer `{ code, message, reason? }`. A
- * `reason`/`code` that already looks like a label travels verbatim — that is
- * the bucket the server chose, and reproducing it is how "storage rejected 116
- * MB" reaches an operator instead of "upload failed" (BLI-2528). Anything else
- * falls back to the message, redacted and capped, because a proxy's error page
- * is unbounded and a route's message can carry a path.
+ * `reason`/`code` that already looks like a label is the bucket the server
+ * chose and travels verbatim at the head — that is how "storage rejected 116
+ * MB" reaches an operator instead of "upload failed" (BLI-2528).
+ *
+ * The label alone is not the whole fact. Every dashboard envelope carries a
+ * `code`, so a label-first helper that stopped at the first match never read
+ * `message` on any refusal: four fleet machines showed `ingest_rejected: http
+ * 500; server reason BLI-E001` while the server had sent "Collector device
+ * lookup failed: <cause>" in the same body. The failure knew its reason and
+ * the collector discarded it. So the sentence rides behind the label as
+ * `label: message`, redacted and capped — a proxy's error page is unbounded
+ * and a route's message can carry a path. A message that merely restates the
+ * `reason` is dropped rather than repeated.
  *
  * `null` means the body said nothing usable — which is itself worth logging as
  * `"none"`, since "the server gave no reason" and "we never looked" are
@@ -53,14 +61,26 @@ export function serverFailureDetail(value) {
     if (!value || typeof value !== "object")
         return null;
     const record = value;
+    let head = null;
+    let headIsReason = false;
     for (const key of ["reason", "code"]) {
         const candidate = record[key];
         if (typeof candidate === "string" && /^[a-z0-9_:.-]{1,80}$/iu.test(candidate)) {
-            return candidate;
+            head = candidate;
+            headIsReason = key === "reason";
+            break;
         }
     }
     const message = record["message"] ?? record["error"];
-    return typeof message === "string" ? boundedFailureDetail(message) : null;
+    const sentence = typeof message === "string" ? boundedFailureDetail(message) : null;
+    if (!head)
+        return sentence;
+    if (!sentence)
+        return head;
+    if (headIsReason && sentence.trim().toLowerCase() === head.trim().toLowerCase()) {
+        return head;
+    }
+    return `${head}: ${sentence}`;
 }
 /** The server's own words when it supplied any, otherwise our fallback. */
 export function responseErrorMessage(value, fallback) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.126",
+  "version": "0.2.128",
   "private": false,
   "type": "module",
   "bin": {
@@ -27,8 +27,8 @@
     "test": "node dist/cli.js --help && node ../../scripts/assert-public-cli-routing.mjs && node ../../scripts/assert-public-cli-verb-help.mjs && node ../../scripts/assert-public-cli-runtime-files.mjs && node ../../scripts/assert-public-cli-exit-contract.mjs && node ../../scripts/assert-public-cli-no-fleet-posts.mjs && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/memory-mcp": "0.1.32",
-    "@bli-cockpit/mcp": "0.1.53",
+    "@bli-cockpit/memory-mcp": "0.1.34",
+    "@bli-cockpit/mcp": "0.1.55",
     "@bli-cockpit/telemetry-core": "0.1.48"
   }
 }