@bli-cockpit/telemetry-core 0.1.28 → 0.1.30

package/dist/collector-heartbeat.d.ts

@@ -58,6 +58,93 @@ export declare const CollectorHeartbeatSchema: z.ZodObject<{
     sessions_outside_root: z.ZodOptional<z.ZodNumber>;
     sessions_new_this_tick: z.ZodOptional<z.ZodNumber>;
     sessions_pending_upload: z.ZodOptional<z.ZodNumber>;
+    memory_install: z.ZodOptional<z.ZodObject<{
+        schema_version: z.ZodLiteral<"memory-install-receipt.v1">;
+        checked_at: z.ZodString;
+        claude: z.ZodObject<{
+            mcp: z.ZodEnum<{
+                unknown: "unknown";
+                ok: "ok";
+                stale: "stale";
+                missing: "missing";
+            }>;
+            hooks: z.ZodEnum<{
+                unknown: "unknown";
+                ok: "ok";
+                stale: "stale";
+                missing: "missing";
+            }>;
+        }, z.core.$strict>;
+        codex: z.ZodObject<{
+            mcp: z.ZodEnum<{
+                unknown: "unknown";
+                ok: "ok";
+                stale: "stale";
+                missing: "missing";
+            }>;
+            skill: z.ZodEnum<{
+                unknown: "unknown";
+                ok: "ok";
+                stale: "stale";
+                missing: "missing";
+            }>;
+            hooks: z.ZodEnum<{
+                unknown: "unknown";
+                ok: "ok";
+                stale: "stale";
+                missing: "missing";
+                needs_trust: "needs_trust";
+                unsupported: "unsupported";
+            }>;
+        }, z.core.$strict>;
+        reasons: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        bin_found: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    setup_receipt: z.ZodOptional<z.ZodObject<{
+        schema_version: z.ZodLiteral<"setup-receipt.v1">;
+        checked_at: z.ZodString;
+        browser: z.ZodObject<{
+            status: z.ZodEnum<{
+                unknown: "unknown";
+                failed: "failed";
+                skipped: "skipped";
+                ok: "ok";
+                stale: "stale";
+                missing: "missing";
+                needs_trust: "needs_trust";
+                unsupported: "unsupported";
+            }>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        device: z.ZodObject<{
+            status: z.ZodEnum<{
+                unknown: "unknown";
+                failed: "failed";
+                skipped: "skipped";
+                ok: "ok";
+                stale: "stale";
+                missing: "missing";
+                needs_trust: "needs_trust";
+                unsupported: "unsupported";
+            }>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        collector: z.ZodObject<{
+            autostart: z.ZodObject<{
+                status: z.ZodEnum<{
+                    unknown: "unknown";
+                    failed: "failed";
+                    skipped: "skipped";
+                    ok: "ok";
+                    stale: "stale";
+                    missing: "missing";
+                    needs_trust: "needs_trust";
+                    unsupported: "unsupported";
+                }>;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type CollectorHeartbeat = z.infer<typeof CollectorHeartbeatSchema>;
 /**

package/dist/collector-heartbeat.js

@@ -24,6 +24,8 @@
  */
 import { z } from "zod";
 import { IsoDateTimeSchema, Sha256Schema, VersionStringSchema } from "./common.js";
+import { MemoryInstallReceiptSchema } from "./memory-install-receipt.js";
+import { SetupReceiptSchema } from "./setup-receipt.js";
 export const COLLECTOR_HEARTBEAT_SCHEMA_VERSION = "collector-heartbeat.v1";
 /** The most roots one machine may declare. Well above any real operator. */
 export const COLLECTOR_HEARTBEAT_MAX_ROOTS = 40;
@@ -112,6 +114,22 @@ export const CollectorHeartbeatSchema = z
         .nonnegative()
         .max(1_000_000)
         .optional(),
+    /**
+     * BLI-3729. Is BLI Memory actually switched on for both agent hosts on
+     * this machine? Six words computed by reading the host configs BACK, not
+     * by remembering what the last install wrote. Optional so a collector too
+     * old to compute it keeps posting — an absent receipt reads as "this
+     * collector predates the receipt", never as "nothing is installed".
+     */
+    memory_install: MemoryInstallReceiptSchema.optional(),
+    /**
+     * BLI-3731. "Is this machine actually connected?" in seven read-back
+     * words — the browser sign-in, the device session, both agent hosts and
+     * the scheduler. Optional so a collector too old to compute it keeps
+     * posting, and so a tick that sends none leaves whatever the device row
+     * already holds rather than blanking it.
+     */
+    setup_receipt: SetupReceiptSchema.optional(),
 })
     .strict();
 /**

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./agent-artifacts.js";
 export * from "./collector-heartbeat.js";
+export * from "./setup-receipt.js";
 export * from "./common.js";
 export * from "./decision-event.js";
 export * from "./decision-event-id.js";
@@ -8,6 +9,7 @@ export * from "./evidence-reconcile.js";
 export * from "./evidence-upload.js";
 export * from "./ingest-dto.js";
 export * from "./local-config.js";
+export * from "./memory-install-receipt.js";
 export * from "./paths.js";
 export * from "./privacy.js";
 export * from "./risk-flags.js";

package/dist/index.js

@@ -1,5 +1,6 @@
 export * from "./agent-artifacts.js";
 export * from "./collector-heartbeat.js";
+export * from "./setup-receipt.js";
 export * from "./common.js";
 export * from "./decision-event.js";
 export * from "./decision-event-id.js";
@@ -8,6 +9,7 @@ export * from "./evidence-reconcile.js";
 export * from "./evidence-upload.js";
 export * from "./ingest-dto.js";
 export * from "./local-config.js";
+export * from "./memory-install-receipt.js";
 export * from "./paths.js";
 export * from "./privacy.js";
 export * from "./risk-flags.js";

package/dist/ingest-dto.d.ts

@@ -401,6 +401,8 @@ export declare const TelemetryIngestEnvelopeSchema: z.ZodObject<{
         started_at: z.ZodString;
         updated_at: z.ZodOptional<z.ZodString>;
         active_ticket_id: z.ZodOptional<z.ZodString>;
+        tower_issue_id: z.ZodOptional<z.ZodString>;
+        linear_ticket_id: z.ZodOptional<z.ZodString>;
         ticket_binding_candidates: z.ZodDefault<z.ZodArray<z.ZodObject<{
             ticket_id: z.ZodString;
             binding_source: z.ZodEnum<{

package/dist/memory-install-receipt.d.ts

@@ -0,0 +1,120 @@
+/**
+ * THE MEMORY RECEIPT (BLI-3729) — is BLI Memory actually switched on, on this
+ * laptop, for both agent hosts?
+ *
+ * `cockpit memory install` already converged the two host configurations and
+ * already wrote a per-target `memory_install` install event. What nobody could
+ * answer was the fleet-wide question: "does Savina's machine have memory hooks
+ * at all?" The install event is a per-run receipt in an outbox; this is the
+ * per-MACHINE state, recomputed every sync tick by READING THE FILES BACK and
+ * carried on the heartbeat, so the ops board can name the machine that is
+ * missing a piece instead of somebody grepping logs.
+ *
+ * Six words, one per thing that can independently be absent:
+ *
+ *   claude.mcp      `~/.claude.json`            → the `bli-memory` MCP server
+ *   claude.hooks    `~/.claude/settings.json`   → SessionStart/UserPromptSubmit/Stop
+ *   codex.mcp       `~/.codex/config.toml`      → `[mcp_servers.bli-memory]`
+ *   codex.skill     `~/.codex/skills/bli-memory/` → the skill files
+ *   codex.hooks     `~/.codex/hooks.json`       → the same three events, USER scope
+ *
+ * `codex.hooks` is the only one with a fourth word, and it is the whole reason
+ * this receipt exists rather than a boolean: Codex requires a person to review
+ * and TRUST a non-managed command hook before it runs (`/hooks` in the CLI),
+ * and records that trust against the hook's current hash. So a Codex machine
+ * can be perfectly installed and still be running nothing. `needs_trust` is
+ * that state, said out loud, and it is what the intern checklist ticket is
+ * for. `unsupported` is the other honest word: a person who set
+ * `[features] hooks = false` has turned the mechanism off, which is a
+ * decision, not a fault.
+ *
+ * **Nothing here is a path.** A home directory names a person; this travels as
+ * six words and a timestamp, exactly like the root labels beside it.
+ */
+import { z } from "zod";
+export declare const MEMORY_INSTALL_RECEIPT_SCHEMA_VERSION = "memory-install-receipt.v1";
+/**
+ * What one piece of the installation is.
+ *
+ *   `ok`      registered, and what is stored is what we would write
+ *   `stale`   something of ours is there, but not what we would write today
+ *             (a hand edit, an older CLI's shape, a bin path that moved)
+ *   `missing` nothing of ours is there
+ *   `unknown` the file could not be read or parsed, so NEITHER of the above is
+ *             claimed — an unreadable config is not an absent one
+ */
+export declare const MemoryInstallPieceSchema: z.ZodEnum<{
+    unknown: "unknown";
+    ok: "ok";
+    stale: "stale";
+    missing: "missing";
+}>;
+export type MemoryInstallPiece = z.infer<typeof MemoryInstallPieceSchema>;
+/**
+ * `codex.hooks` carries two more words than the others.
+ *
+ * `needs_trust` — the hooks file holds our three entries and Codex has not
+ * been told to trust them yet. The hooks are INSTALLED and NOT RUNNING, which
+ * is a state no other piece here has.
+ * `unsupported` — hooks are turned off in this person's `config.toml`
+ * (`[features] hooks = false`, or the deprecated `codex_hooks = false` alias).
+ */
+export declare const MemoryInstallHooksPieceSchema: z.ZodEnum<{
+    unknown: "unknown";
+    ok: "ok";
+    stale: "stale";
+    missing: "missing";
+    needs_trust: "needs_trust";
+    unsupported: "unsupported";
+}>;
+export type MemoryInstallHooksPiece = z.infer<typeof MemoryInstallHooksPieceSchema>;
+export declare const MemoryInstallReceiptSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<"memory-install-receipt.v1">;
+    checked_at: z.ZodString;
+    claude: z.ZodObject<{
+        mcp: z.ZodEnum<{
+            unknown: "unknown";
+            ok: "ok";
+            stale: "stale";
+            missing: "missing";
+        }>;
+        hooks: z.ZodEnum<{
+            unknown: "unknown";
+            ok: "ok";
+            stale: "stale";
+            missing: "missing";
+        }>;
+    }, z.core.$strict>;
+    codex: z.ZodObject<{
+        mcp: z.ZodEnum<{
+            unknown: "unknown";
+            ok: "ok";
+            stale: "stale";
+            missing: "missing";
+        }>;
+        skill: z.ZodEnum<{
+            unknown: "unknown";
+            ok: "ok";
+            stale: "stale";
+            missing: "missing";
+        }>;
+        hooks: z.ZodEnum<{
+            unknown: "unknown";
+            ok: "ok";
+            stale: "stale";
+            missing: "missing";
+            needs_trust: "needs_trust";
+            unsupported: "unsupported";
+        }>;
+    }, z.core.$strict>;
+    reasons: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    bin_found: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type MemoryInstallReceipt = z.infer<typeof MemoryInstallReceiptSchema>;
+/** Every piece is `ok`. The one question the board asks first. */
+export declare function memoryInstallFullyOn(receipt: MemoryInstallReceipt): boolean;
+/**
+ * The pieces that are NOT `ok`, as `host.piece=word` labels, in a fixed order
+ * so two machines' receipts read the same way. Empty when everything is on.
+ */
+export declare function memoryInstallGaps(receipt: MemoryInstallReceipt): string[];

package/dist/memory-install-receipt.js

@@ -0,0 +1,133 @@
+/**
+ * THE MEMORY RECEIPT (BLI-3729) — is BLI Memory actually switched on, on this
+ * laptop, for both agent hosts?
+ *
+ * `cockpit memory install` already converged the two host configurations and
+ * already wrote a per-target `memory_install` install event. What nobody could
+ * answer was the fleet-wide question: "does Savina's machine have memory hooks
+ * at all?" The install event is a per-run receipt in an outbox; this is the
+ * per-MACHINE state, recomputed every sync tick by READING THE FILES BACK and
+ * carried on the heartbeat, so the ops board can name the machine that is
+ * missing a piece instead of somebody grepping logs.
+ *
+ * Six words, one per thing that can independently be absent:
+ *
+ *   claude.mcp      `~/.claude.json`            → the `bli-memory` MCP server
+ *   claude.hooks    `~/.claude/settings.json`   → SessionStart/UserPromptSubmit/Stop
+ *   codex.mcp       `~/.codex/config.toml`      → `[mcp_servers.bli-memory]`
+ *   codex.skill     `~/.codex/skills/bli-memory/` → the skill files
+ *   codex.hooks     `~/.codex/hooks.json`       → the same three events, USER scope
+ *
+ * `codex.hooks` is the only one with a fourth word, and it is the whole reason
+ * this receipt exists rather than a boolean: Codex requires a person to review
+ * and TRUST a non-managed command hook before it runs (`/hooks` in the CLI),
+ * and records that trust against the hook's current hash. So a Codex machine
+ * can be perfectly installed and still be running nothing. `needs_trust` is
+ * that state, said out loud, and it is what the intern checklist ticket is
+ * for. `unsupported` is the other honest word: a person who set
+ * `[features] hooks = false` has turned the mechanism off, which is a
+ * decision, not a fault.
+ *
+ * **Nothing here is a path.** A home directory names a person; this travels as
+ * six words and a timestamp, exactly like the root labels beside it.
+ */
+import { z } from "zod";
+import { IsoDateTimeSchema } from "./common.js";
+export const MEMORY_INSTALL_RECEIPT_SCHEMA_VERSION = "memory-install-receipt.v1";
+/**
+ * What one piece of the installation is.
+ *
+ *   `ok`      registered, and what is stored is what we would write
+ *   `stale`   something of ours is there, but not what we would write today
+ *             (a hand edit, an older CLI's shape, a bin path that moved)
+ *   `missing` nothing of ours is there
+ *   `unknown` the file could not be read or parsed, so NEITHER of the above is
+ *             claimed — an unreadable config is not an absent one
+ */
+export const MemoryInstallPieceSchema = z.enum(["ok", "stale", "missing", "unknown"]);
+/**
+ * `codex.hooks` carries two more words than the others.
+ *
+ * `needs_trust` — the hooks file holds our three entries and Codex has not
+ * been told to trust them yet. The hooks are INSTALLED and NOT RUNNING, which
+ * is a state no other piece here has.
+ * `unsupported` — hooks are turned off in this person's `config.toml`
+ * (`[features] hooks = false`, or the deprecated `codex_hooks = false` alias).
+ */
+export const MemoryInstallHooksPieceSchema = z.enum([
+    "ok",
+    "needs_trust",
+    "stale",
+    "missing",
+    "unknown",
+    "unsupported",
+]);
+/**
+ * A closed reason label per piece, for the operator who asks "why `stale`?".
+ * Bounded and charset-restricted for the same reason `last_sync_reason` is:
+ * nothing content-bearing may ride in on it.
+ */
+const ReasonLabelSchema = z
+    .string()
+    .trim()
+    .min(1)
+    .max(60)
+    .regex(/^[a-z0-9_:.-]+$/iu);
+export const MemoryInstallReceiptSchema = z
+    .object({
+    schema_version: z.literal(MEMORY_INSTALL_RECEIPT_SCHEMA_VERSION),
+    checked_at: IsoDateTimeSchema,
+    claude: z
+        .object({
+        mcp: MemoryInstallPieceSchema,
+        hooks: MemoryInstallPieceSchema,
+    })
+        .strict(),
+    codex: z
+        .object({
+        mcp: MemoryInstallPieceSchema,
+        skill: MemoryInstallPieceSchema,
+        hooks: MemoryInstallHooksPieceSchema,
+    })
+        .strict(),
+    /**
+     * One label per piece, keyed by the same names. Optional so an older
+     * collector that only computes the words still validates.
+     */
+    reasons: z.record(z.string().max(24), ReasonLabelSchema).optional(),
+    /**
+     * Whether `bli-memory-mcp` resolved on this machine at all. A machine
+     * where every piece is `missing` because the SERVER is not installed yet
+     * is a different machine from one whose configs were wiped, and the
+     * install path deliberately writes nothing in the first case
+     * (`no_bin_no_write`).
+     */
+    bin_found: z.boolean().optional(),
+})
+    .strict();
+/** Every piece is `ok`. The one question the board asks first. */
+export function memoryInstallFullyOn(receipt) {
+    return (receipt.claude.mcp === "ok" &&
+        receipt.claude.hooks === "ok" &&
+        receipt.codex.mcp === "ok" &&
+        receipt.codex.skill === "ok" &&
+        receipt.codex.hooks === "ok");
+}
+/**
+ * The pieces that are NOT `ok`, as `host.piece=word` labels, in a fixed order
+ * so two machines' receipts read the same way. Empty when everything is on.
+ */
+export function memoryInstallGaps(receipt) {
+    const gaps = [];
+    if (receipt.claude.mcp !== "ok")
+        gaps.push(`claude.mcp=${receipt.claude.mcp}`);
+    if (receipt.claude.hooks !== "ok")
+        gaps.push(`claude.hooks=${receipt.claude.hooks}`);
+    if (receipt.codex.mcp !== "ok")
+        gaps.push(`codex.mcp=${receipt.codex.mcp}`);
+    if (receipt.codex.skill !== "ok")
+        gaps.push(`codex.skill=${receipt.codex.skill}`);
+    if (receipt.codex.hooks !== "ok")
+        gaps.push(`codex.hooks=${receipt.codex.hooks}`);
+    return gaps;
+}

package/dist/setup-receipt.d.ts

@@ -0,0 +1,146 @@
+import { z } from "zod";
+import type { MemoryInstallReceipt } from "./memory-install-receipt.js";
+/**
+ * "Is this machine actually connected?" — one block, read back off the machine
+ * (BLI-3731).
+ *
+ * Installing was never the hard part. What nobody could answer was whether
+ * Savina's laptop has Codex hooks trusted, or whether Viet's autostart survived
+ * a reinstall. This is that answer, in seven words, computed where the truth
+ * is and carried to wherever a person reads it: the terminal
+ * (`cockpit status`, `cockpit doctor`), the heartbeat, the ops board and
+ * JARVIS's `readFleet`.
+ *
+ *   browser ✓ · device ✓ · claude mcp ✓ hooks ✓ · codex mcp ✓ skill ✓
+ *   hooks needs_trust · collector autostart ✓
+ *
+ * **The five middle words are BLI-3729's, not ours.** `MemoryInstallReceipt`
+ * already owns both agent hosts, it is already computed by reading the host
+ * configs back, and it already rides the heartbeat under `memory_install`.
+ * This schema carries only the three pieces that ticket had no way to see —
+ * whether a browser sign-in ever happened, whether the device session is still
+ * good, and whether the scheduler is registered — and the renderers below JOIN
+ * the two. One fact stored twice on one row is one fact that can disagree
+ * with itself.
+ *
+ * **Every word is a READ-BACK, never a memory of what we wrote** (BLI-2541:
+ * `cockpit autostart` validated a correct Windows task against the strings
+ * Cockpit had sent and rejected it on every machine for months). A piece this
+ * run did not actually inspect is `unknown`, never `missing` — "we did not
+ * look" and "it is not there" are different facts and only one of them is
+ * somebody's problem.
+ *
+ * **Metadata only.** Three words, three reason labels, one timestamp. No path
+ * — a home directory names a person — no token, no email.
+ */
+export declare const SETUP_RECEIPT_SCHEMA_VERSION = "setup-receipt.v1";
+/**
+ * What one piece of the setup can be. Deliberately small and closed: a word a
+ * person can read at a glance. The vocabulary is a superset of
+ * `MemoryInstallPiece`'s, so one renderer can print both halves.
+ */
+export declare const SetupPieceStatusSchema: z.ZodEnum<{
+    unknown: "unknown";
+    failed: "failed";
+    skipped: "skipped";
+    ok: "ok";
+    stale: "stale";
+    missing: "missing";
+    needs_trust: "needs_trust";
+    unsupported: "unsupported";
+}>;
+export type SetupPieceStatus = z.infer<typeof SetupPieceStatusSchema>;
+declare const PieceSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        unknown: "unknown";
+        failed: "failed";
+        skipped: "skipped";
+        ok: "ok";
+        stale: "stale";
+        missing: "missing";
+        needs_trust: "needs_trust";
+        unsupported: "unsupported";
+    }>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type SetupPiece = z.infer<typeof PieceSchema>;
+export declare const SetupReceiptSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<"setup-receipt.v1">;
+    checked_at: z.ZodString;
+    browser: z.ZodObject<{
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            failed: "failed";
+            skipped: "skipped";
+            ok: "ok";
+            stale: "stale";
+            missing: "missing";
+            needs_trust: "needs_trust";
+            unsupported: "unsupported";
+        }>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    device: z.ZodObject<{
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            failed: "failed";
+            skipped: "skipped";
+            ok: "ok";
+            stale: "stale";
+            missing: "missing";
+            needs_trust: "needs_trust";
+            unsupported: "unsupported";
+        }>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    collector: z.ZodObject<{
+        autostart: z.ZodObject<{
+            status: z.ZodEnum<{
+                unknown: "unknown";
+                failed: "failed";
+                skipped: "skipped";
+                ok: "ok";
+                stale: "stale";
+                missing: "missing";
+                needs_trust: "needs_trust";
+                unsupported: "unsupported";
+            }>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type SetupReceipt = z.infer<typeof SetupReceiptSchema>;
+export interface SetupReceiptPiece {
+    key: string;
+    label: string;
+    piece: SetupPiece;
+}
+/**
+ * Every piece in the order the one-line block prints them, with BLI-3729's
+ * five memory words spliced into the middle when there is a memory receipt to
+ * splice. Without one, the memory keys are still LISTED, as `unknown` — a
+ * machine whose memory state nobody knows must not read as a machine with no
+ * memory pieces at all.
+ */
+export declare function setupReceiptPieces(receipt: SetupReceipt, memory?: MemoryInstallReceipt | null): SetupReceiptPiece[];
+/**
+ * The keys of every piece that is not `ok` — what a manager wants named, and
+ * what `readFleet` says out loud ("Savina's machine has no Codex hooks
+ * trusted"). `unknown` counts as a gap on purpose: a machine nobody can read
+ * is not a machine anybody should call fine.
+ */
+export declare function setupReceiptGaps(receipt: SetupReceipt, memory?: MemoryInstallReceipt | null): string[];
+/**
+ * The one line, exactly as a terminal prints it and as the ops board renders
+ * it. Written here, in the shared package, so the CLI and the dashboard cannot
+ * word the same machine's state two different ways.
+ *
+ * Five groups, dot-separated, in the order somebody debugs them: the two
+ * sign-ins first, then each agent host, then the scheduler. The grouping is
+ * the whole readability of the line — `hooks` reads as Claude's or Codex's
+ * only because of which side of a dot it sits on.
+ */
+export declare function setupReceiptLine(receipt: SetupReceipt, memory?: MemoryInstallReceipt | null): string;
+/** `ok` is a tick, a broken piece is a cross, and everything else says its own word. */
+export declare function setupPieceMark(status: SetupPieceStatus): string;
+export {};

package/dist/setup-receipt.js

@@ -0,0 +1,197 @@
+import { z } from "zod";
+import { IsoDateTimeSchema } from "./common.js";
+/**
+ * "Is this machine actually connected?" — one block, read back off the machine
+ * (BLI-3731).
+ *
+ * Installing was never the hard part. What nobody could answer was whether
+ * Savina's laptop has Codex hooks trusted, or whether Viet's autostart survived
+ * a reinstall. This is that answer, in seven words, computed where the truth
+ * is and carried to wherever a person reads it: the terminal
+ * (`cockpit status`, `cockpit doctor`), the heartbeat, the ops board and
+ * JARVIS's `readFleet`.
+ *
+ *   browser ✓ · device ✓ · claude mcp ✓ hooks ✓ · codex mcp ✓ skill ✓
+ *   hooks needs_trust · collector autostart ✓
+ *
+ * **The five middle words are BLI-3729's, not ours.** `MemoryInstallReceipt`
+ * already owns both agent hosts, it is already computed by reading the host
+ * configs back, and it already rides the heartbeat under `memory_install`.
+ * This schema carries only the three pieces that ticket had no way to see —
+ * whether a browser sign-in ever happened, whether the device session is still
+ * good, and whether the scheduler is registered — and the renderers below JOIN
+ * the two. One fact stored twice on one row is one fact that can disagree
+ * with itself.
+ *
+ * **Every word is a READ-BACK, never a memory of what we wrote** (BLI-2541:
+ * `cockpit autostart` validated a correct Windows task against the strings
+ * Cockpit had sent and rejected it on every machine for months). A piece this
+ * run did not actually inspect is `unknown`, never `missing` — "we did not
+ * look" and "it is not there" are different facts and only one of them is
+ * somebody's problem.
+ *
+ * **Metadata only.** Three words, three reason labels, one timestamp. No path
+ * — a home directory names a person — no token, no email.
+ */
+export const SETUP_RECEIPT_SCHEMA_VERSION = "setup-receipt.v1";
+/**
+ * What one piece of the setup can be. Deliberately small and closed: a word a
+ * person can read at a glance. The vocabulary is a superset of
+ * `MemoryInstallPiece`'s, so one renderer can print both halves.
+ */
+export const SetupPieceStatusSchema = z.enum([
+    /** Read back, correct. */
+    "ok",
+    /** Read back, nothing of ours is there. */
+    "missing",
+    /** Read back, something of ours is there but not what we would write. */
+    "stale",
+    /**
+     * Installed correctly and waiting on ONE human action. Today only Codex
+     * hooks, which the host requires a person to trust once per machine. It is
+     * its own word rather than `missing` because nothing is broken and no
+     * command fixes it.
+     */
+    "needs_trust",
+    /** The mechanism is switched off by a person's own choice. */
+    "unsupported",
+    /** Deliberately not done, and no file was touched. Carries its reason. */
+    "skipped",
+    /** Tried, and did not work. Carries its reason. */
+    "failed",
+    /**
+     * This run did not look. NEVER a substitute for `missing`: a collector too
+     * old to compute a piece, a dry run, and a probe that could not run all land
+     * here, and every one of them means "ask again", not "fix it".
+     */
+    "unknown",
+]);
+const PieceSchema = z
+    .object({
+    status: SetupPieceStatusSchema,
+    /**
+     * A reason label, never prose: `never_signed_in`, `session_expired`,
+     * `autostart_not_loaded`. Bounded and charset-restricted so nothing
+     * content-bearing can ride in on it.
+     */
+    reason: z
+        .string()
+        .trim()
+        .min(1)
+        .max(120)
+        .regex(/^[a-z0-9_:.-]+$/iu)
+        .optional(),
+})
+    .strict();
+export const SetupReceiptSchema = z
+    .object({
+    schema_version: z.literal(SETUP_RECEIPT_SCHEMA_VERSION),
+    /** When these words were read off this machine. Ages out; never trusted stale. */
+    checked_at: IsoDateTimeSchema,
+    /** Did a person ever sign a browser in for this machine? */
+    browser: PieceSchema,
+    /** Is the device session on disk still one the dashboard would honour? */
+    device: PieceSchema,
+    /** The 15-minute scheduler: launchd on macOS, Task Scheduler on Windows. */
+    collector: z.object({ autostart: PieceSchema }).strict(),
+})
+    .strict();
+/**
+ * Every piece in the order the one-line block prints them, with BLI-3729's
+ * five memory words spliced into the middle when there is a memory receipt to
+ * splice. Without one, the memory keys are still LISTED, as `unknown` — a
+ * machine whose memory state nobody knows must not read as a machine with no
+ * memory pieces at all.
+ */
+export function setupReceiptPieces(receipt, memory) {
+    const memoryPiece = (word, key) => {
+        if (!word)
+            return { status: "unknown", reason: "memory_receipt_absent" };
+        const reason = memory?.reasons?.[key];
+        return {
+            status: word,
+            ...(word !== "ok" && reason ? { reason } : {}),
+        };
+    };
+    return [
+        { key: "browser", label: "browser", piece: receipt.browser },
+        { key: "device", label: "device", piece: receipt.device },
+        {
+            key: "claude.mcp",
+            label: "claude mcp",
+            piece: memoryPiece(memory?.claude.mcp, "claude.mcp"),
+        },
+        {
+            key: "claude.hooks",
+            label: "hooks",
+            piece: memoryPiece(memory?.claude.hooks, "claude.hooks"),
+        },
+        {
+            key: "codex.mcp",
+            label: "codex mcp",
+            piece: memoryPiece(memory?.codex.mcp, "codex.mcp"),
+        },
+        {
+            key: "codex.skill",
+            label: "skill",
+            piece: memoryPiece(memory?.codex.skill, "codex.skill"),
+        },
+        {
+            key: "codex.hooks",
+            label: "hooks",
+            piece: memoryPiece(memory?.codex.hooks, "codex.hooks"),
+        },
+        {
+            key: "collector.autostart",
+            label: "collector autostart",
+            piece: receipt.collector.autostart,
+        },
+    ];
+}
+/**
+ * The keys of every piece that is not `ok` — what a manager wants named, and
+ * what `readFleet` says out loud ("Savina's machine has no Codex hooks
+ * trusted"). `unknown` counts as a gap on purpose: a machine nobody can read
+ * is not a machine anybody should call fine.
+ */
+export function setupReceiptGaps(receipt, memory) {
+    return setupReceiptPieces(receipt, memory)
+        .filter(({ piece }) => piece.status !== "ok")
+        .map(({ key }) => key);
+}
+/**
+ * The one line, exactly as a terminal prints it and as the ops board renders
+ * it. Written here, in the shared package, so the CLI and the dashboard cannot
+ * word the same machine's state two different ways.
+ *
+ * Five groups, dot-separated, in the order somebody debugs them: the two
+ * sign-ins first, then each agent host, then the scheduler. The grouping is
+ * the whole readability of the line — `hooks` reads as Claude's or Codex's
+ * only because of which side of a dot it sits on.
+ */
+export function setupReceiptLine(receipt, memory) {
+    const groups = new Map([
+        ["browser", []],
+        ["device", []],
+        ["claude", []],
+        ["codex", []],
+        ["collector", []],
+    ]);
+    for (const { key, label, piece } of setupReceiptPieces(receipt, memory)) {
+        const group = key.includes(".") ? key.split(".")[0] : key;
+        groups.get(group)?.push(`${label} ${setupPieceMark(piece.status)}`);
+    }
+    return [...groups.values()]
+        .filter((group) => group.length > 0)
+        .map((group) => group.join(" "))
+        .join(" · ");
+}
+/** `ok` is a tick, a broken piece is a cross, and everything else says its own word. */
+export function setupPieceMark(status) {
+    if (status === "ok")
+        return "✓";
+    if (status === "missing" || status === "failed" || status === "stale") {
+        return "✗";
+    }
+    return status;
+}

package/dist/ticket-id.d.ts

@@ -1 +1,44 @@
+/**
+ * WHICH TRACKER MINTED THIS ID (BLI-3779).
+ *
+ * Tower runs its own issue tracker beside Linear during the dual-run, and both
+ * spell an identifier the same way: a team key, a hyphen, a number. Two facts
+ * tell them apart, and neither is a guess:
+ *
+ *  - **The number.** Tower's tracker mints from `BLI-10001` up;
+ *    Linear's BLI team is in the 3,000s. An id at or above
+ *    `TOWER_NATIVE_ISSUE_NUMBER_FLOOR` is one only Tower could have issued.
+ *    The dashboard's `lib/jarvis/chat-v2/issue-word-boundary.ts` (BLI-3783)
+ *    re-exports this constant rather than keeping a second copy of it.
+ *  - **The title.** A Tower-native row that mirrors a Linear ticket ends its
+ *    title with `[BLI-3779]` — Edward's dogfooding convention, 2026-09-05 —
+ *    so the Linear id a Tower row stands for is READ, never inferred.
+ *
+ * Exact after upper-casing, never fuzzy: the `person-identity.ts` discipline,
+ * for the same reason. A wrong match binds a session's work to somebody
+ * else's ticket.
+ */
+/**
+ * The first identifier Tower's own tracker mints. Linear's BLI team is in the
+ * 3,000s as of 2026-09-05 and would need six thousand more tickets to reach
+ * it; if it ever does, this constant moves and `work_issues.source` becomes
+ * the only honest discriminator.
+ */
+export declare const TOWER_NATIVE_ISSUE_NUMBER_FLOOR = 10000;
 export declare function parseTicketIdFromText(value: string): string | null;
+/** Is this the shape either tracker uses for an identifier? */
+export declare function looksLikeIssueIdentifier(value: string): boolean;
+/** The one spelling of an identifier: trimmed and upper-cased, or null. */
+export declare function normalizeIssueIdentifier(value: string): string | null;
+/**
+ * Is this an id only TOWER's tracker could have minted? A fact about the
+ * number, not a claim about any row: `BLI-10042` cannot be in Linear whether
+ * or not it is in Tower.
+ */
+export declare function isTowerNativeIssueId(value: string): boolean;
+/**
+ * The Linear id a Tower-native title mirrors: the LAST `[BLI-3779]` in the
+ * title, because a title may quote another ticket in its prose and the
+ * convention puts the mirrored id at the end.
+ */
+export declare function mirroredTicketIdInTitle(title: string): string | null;

package/dist/ticket-id.js

@@ -1,4 +1,61 @@
+/**
+ * WHICH TRACKER MINTED THIS ID (BLI-3779).
+ *
+ * Tower runs its own issue tracker beside Linear during the dual-run, and both
+ * spell an identifier the same way: a team key, a hyphen, a number. Two facts
+ * tell them apart, and neither is a guess:
+ *
+ *  - **The number.** Tower's tracker mints from `BLI-10001` up;
+ *    Linear's BLI team is in the 3,000s. An id at or above
+ *    `TOWER_NATIVE_ISSUE_NUMBER_FLOOR` is one only Tower could have issued.
+ *    The dashboard's `lib/jarvis/chat-v2/issue-word-boundary.ts` (BLI-3783)
+ *    re-exports this constant rather than keeping a second copy of it.
+ *  - **The title.** A Tower-native row that mirrors a Linear ticket ends its
+ *    title with `[BLI-3779]` — Edward's dogfooding convention, 2026-09-05 —
+ *    so the Linear id a Tower row stands for is READ, never inferred.
+ *
+ * Exact after upper-casing, never fuzzy: the `person-identity.ts` discipline,
+ * for the same reason. A wrong match binds a session's work to somebody
+ * else's ticket.
+ */
+/** `BLI-3654`, `TRI-12` — a team key, a hyphen, a number, and nothing else. */
+const ISSUE_IDENTIFIER = /^[A-Z][A-Z0-9]{1,12}-\d+$/;
+/**
+ * The first identifier Tower's own tracker mints. Linear's BLI team is in the
+ * 3,000s as of 2026-09-05 and would need six thousand more tickets to reach
+ * it; if it ever does, this constant moves and `work_issues.source` becomes
+ * the only honest discriminator.
+ */
+export const TOWER_NATIVE_ISSUE_NUMBER_FLOOR = 10_000;
 export function parseTicketIdFromText(value) {
     const match = value.match(/\b[A-Z][A-Z0-9]{1,12}-\d+\b/);
     return match?.[0] ?? null;
 }
+/** Is this the shape either tracker uses for an identifier? */
+export function looksLikeIssueIdentifier(value) {
+    return ISSUE_IDENTIFIER.test(value.trim().toUpperCase());
+}
+/** The one spelling of an identifier: trimmed and upper-cased, or null. */
+export function normalizeIssueIdentifier(value) {
+    const normalized = value.trim().toUpperCase();
+    return ISSUE_IDENTIFIER.test(normalized) ? normalized : null;
+}
+/**
+ * Is this an id only TOWER's tracker could have minted? A fact about the
+ * number, not a claim about any row: `BLI-10042` cannot be in Linear whether
+ * or not it is in Tower.
+ */
+export function isTowerNativeIssueId(value) {
+    const match = /^[A-Z][A-Z0-9]{1,12}-(\d+)$/.exec(value.trim().toUpperCase());
+    return match ? Number(match[1]) >= TOWER_NATIVE_ISSUE_NUMBER_FLOOR : false;
+}
+/**
+ * The Linear id a Tower-native title mirrors: the LAST `[BLI-3779]` in the
+ * title, because a title may quote another ticket in its prose and the
+ * convention puts the mirrored id at the end.
+ */
+export function mirroredTicketIdInTitle(title) {
+    const matches = [...title.matchAll(/\[([A-Z][A-Z0-9]{1,12}-\d+)\]/gi)];
+    const last = matches.at(-1);
+    return last ? last[1].toUpperCase() : null;
+}

package/dist/work-context.d.ts

@@ -85,6 +85,8 @@ export declare const LocalWorkContextSchema: z.ZodObject<{
     started_at: z.ZodString;
     updated_at: z.ZodOptional<z.ZodString>;
     active_ticket_id: z.ZodOptional<z.ZodString>;
+    tower_issue_id: z.ZodOptional<z.ZodString>;
+    linear_ticket_id: z.ZodOptional<z.ZodString>;
     ticket_binding_candidates: z.ZodDefault<z.ZodArray<z.ZodObject<{
         ticket_id: z.ZodString;
         binding_source: z.ZodEnum<{

package/dist/work-context.js

@@ -76,6 +76,20 @@ export const LocalWorkContextSchema = z
     started_at: IsoDateTimeSchema,
     updated_at: IsoDateTimeSchema.optional(),
     active_ticket_id: NonEmptyStringSchema.optional(),
+    /**
+     * BLI-3779, the dual-run: one piece of work has an id in TWO trackers, so
+     * the context carries both beside `active_ticket_id` (which stays exactly
+     * what the person typed — rewriting it would move every downstream
+     * attribution to an id nobody bound).
+     *
+     * `tower_issue_id` is a `work_issues.identifier` (`BLI-10019`);
+     * `linear_ticket_id` is the Linear one (`BLI-3779`). Both OPTIONAL and
+     * both absent when nothing was resolved: `cockpit start` never blocks a
+     * session on a tracker lookup (session-first commandment), so an
+     * unresolved ticket is a named gap, never a missing context.
+     */
+    tower_issue_id: NonEmptyStringSchema.optional(),
+    linear_ticket_id: NonEmptyStringSchema.optional(),
     ticket_binding_candidates: z
         .array(TicketBindingCandidateSchema)
         .default([]),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/telemetry-core",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",