@bli-cockpit/cli 0.2.63 → 0.2.65

package/dist/commands/issue.js

@@ -25,6 +25,7 @@
  * (`agent-door.ts`) — `issue_not_found_or_unreadable`, `invalid_state`,
  * `needs_rls_client`, `comment_too_long`, and so on.
  */
+import { mirroredTicketIdInTitle } from "@bli-cockpit/telemetry-core";
 import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor, } from "./agent-door.js";
 import { writeLine } from "./cli-io.js";
 import { READ_DEADLINE_MS, TAG, resolveProjectId, } from "./issue-contracts.js";
@@ -118,17 +119,25 @@ async function showIssue(command, door) {
     if (!commentsAnswer.ok) {
         writeLine(door.io.stderr, `${TAG} comments unread ${JSON.stringify({ reason: commentsAnswer.reason, issue_id: issue.id })}`);
     }
+    // BLI-3779: during the dual-run a Tower-native row stands for a Linear
+    // ticket, and says so in its own title (`… [BLI-3779]`). Read it out rather
+    // than making every caller parse the title — `cockpit start --ticket` binds
+    // a session to both ids, and this is where a person checks which they are.
+    const linearTicketId = mirroredTicketIdInTitle(issue.title ?? "");
     if (door.json) {
         return emitAgentDoor(door, {
             ok: true,
             issue,
             comments,
+            ...(linearTicketId ? { linear_ticket_id: linearTicketId } : {}),
             ...(commentsAnswer.ok ? {} : { comments_unread_reason: commentsAnswer.reason }),
         });
     }
     writeLine(door.io.stdout, `${issue.identifier}  ${issue.title}`);
     writeLine(door.io.stdout, `${issue.state}  ·  priority ${issue.priority ?? 0}  ·  assignee ${issue.assignee_id ?? "(nobody)"}  ·  updated ${issue.updated_at}`);
     writeLine(door.io.stdout, `id ${issue.id}${issue.parent_id ? `  ·  parent ${issue.parent_id}` : ""}`);
+    if (linearTicketId)
+        writeLine(door.io.stdout, `Linear: ${linearTicketId}`);
     writeLine(door.io.stdout, "");
     writeLine(door.io.stdout, issue.description ?? "(no description)");
     if (comments.length > 0) {

package/dist/commands/jarvis-answer-envelope.js

@@ -27,6 +27,25 @@
  * older `reply` / `thread` / `traceId` / `model` / `trace` / `latency` /
  * `clientLatency` keys are untouched, because scripts already read them and a
  * one-contract ticket that broke the contract would be a joke.
+ *
+ * ## Where `sources` comes from (BLI-3770)
+ *
+ * From the DOOR, as objects, when the door sends them: `POST /api/jarvis/cli`
+ * carries `sources` built from the citations the grounding layer minted, and
+ * the `Source:` lines inside `answer` are rendered from that same array. The
+ * older derivation — a line-anchored regex over the finished prose — could
+ * only find a citation the renderer happened to put on its own line, so QA
+ * tick 16's c9, c9b and n9 (all off `searchEverything`) ended *"…Source:
+ * issue, at /work/BLI-3706, by …"* INSIDE the final sentence and returned
+ * `"sources": []`: the person saw a citation, the machine did not.
+ *
+ * The prose derivation survives as the FALLBACK, for a dashboard deployed
+ * before that door field existed, and it is wider than it was: a whole
+ * `Sources:` line (plural, any case, bulleted) counts — that is what the
+ * server itself treats as provenance — and so does a citation that begins a
+ * sentence inside a paragraph. A `Source:` in the MIDDLE of a sentence ("the
+ * Source: field on that row was blank") is prose about a source, not a
+ * source, and is deliberately not matched.
  */
 /**
  * Every key of the envelope, in the order it is written. The literal list IS
@@ -43,8 +62,20 @@ export const JARVIS_ANSWER_ENVELOPE_KEYS = [
     "degraded",
     "degraded_reasons",
 ];
-/** A `Source:` line, as the grounding gate renders it into the answer. */
-const SOURCE_LINE = /^\s*Source:\s*\S/;
+/**
+ * A citation line, in every shape the server itself treats as one.
+ *
+ * BLI-3770 widened this from `/^\s*Source:\s*\S/` to mirror
+ * `apps/dashboard/src/lib/jarvis/chat-v2/provenance-lines.ts`, which matches
+ * `sources?` case-insensitively with an optional bullet. The narrow version
+ * meant a `Sources: …` line the server had already lifted out of the body as
+ * provenance, and put straight back under the answer, was not a source to
+ * this side: one thing, two definitions, in two packages.
+ */
+const SOURCE_LINE = /^\s*(?:[-*\u2022]\s+)?sources?\s*:\s*\S/i;
+/** The receipt's link, as `appendCitations` lays it out: `<url>` after the words. */
+const BRACKETED_LINK = /\s*<(https?:\/\/[^>\s]+)>\s*$/;
+const TRAILING_LINK = /\s+(https?:\/\/\S+)\s*$/;
 /**
  * The `Source:` lines inside an answer. Pure string work on what the server
  * already sent — this side never decides what a source IS, it only finds the
@@ -56,6 +87,90 @@ export function extractSourceLines(answer) {
         .map((line) => line.trim())
         .filter((line) => SOURCE_LINE.test(line));
 }
+/** The words and the link, kept apart, the way every surface renders them. */
+function splitLink(line) {
+    const trimmed = line.trim().replace(/^[-*\u2022]\s+/, "");
+    const bracketed = trimmed.match(BRACKETED_LINK);
+    if (bracketed)
+        return { label: trimmed.slice(0, bracketed.index).trim(), href: bracketed[1] ?? null };
+    const trailing = trimmed.match(TRAILING_LINK);
+    if (trailing)
+        return { label: trimmed.slice(0, trailing.index).trim(), href: trailing[1] ?? null };
+    return { label: trimmed, href: null };
+}
+/**
+ * A citation the model wrote INSIDE a paragraph (BLI-3770).
+ *
+ * It counts when it begins a sentence, which is the shape QA tick 16 caught
+ * three times. It deliberately does not count in the middle of one — "the
+ * Source: field on that row was blank" is a sentence about a field, and
+ * treating it as a receipt would put prose in a contract that is supposed to
+ * carry evidence.
+ */
+function inlineSourceFragments(line) {
+    return line
+        .split(/(?<=[.!?])\s+/)
+        .map((part) => part.trim())
+        .filter((part) => SOURCE_LINE.test(part));
+}
+/**
+ * The fallback derivation: what this side can tell from the answer alone.
+ *
+ * Only reached when the door sent no structured `sources` — a dashboard
+ * deployed before BLI-3770, or a turn whose citation nothing minted. Every
+ * row it produces is labelled `kind: "prose"` so a consumer can tell a
+ * recovered line from a minted receipt.
+ */
+export function sourcesFromAnswer(answer) {
+    const found = [];
+    const seen = new Set();
+    const add = (text) => {
+        const { label, href } = splitLink(text);
+        if (!label || seen.has(label))
+            return;
+        seen.add(label);
+        found.push({ kind: "prose", label, href, id: null, tool: null });
+    };
+    for (const raw of answer.split("\n")) {
+        const line = raw.trim();
+        if (!line)
+            continue;
+        if (SOURCE_LINE.test(line)) {
+            add(line);
+            continue;
+        }
+        for (const fragment of inlineSourceFragments(line))
+            add(fragment);
+    }
+    return found;
+}
+/**
+ * The door's own `sources`, checked rather than trusted. A field that arrives
+ * as something other than a list of labelled objects is treated as absent, so
+ * a malformed body degrades to the prose fallback instead of putting
+ * `[object Object]` in front of an agent.
+ */
+function doorSources(sent) {
+    if (!Array.isArray(sent))
+        return [];
+    const rows = [];
+    for (const entry of sent) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const row = entry;
+        const label = typeof row.label === "string" ? row.label.trim() : "";
+        if (!label)
+            continue;
+        rows.push({
+            kind: typeof row.kind === "string" && row.kind ? row.kind : "unknown",
+            label,
+            href: typeof row.href === "string" ? row.href : null,
+            id: typeof row.id === "string" ? row.id : null,
+            tool: typeof row.tool === "string" ? row.tool : null,
+        });
+    }
+    return rows;
+}
 export function buildJarvisAnswerEnvelope(input) {
     const reasons = [];
     if (input.modelFallback === true)
@@ -68,10 +183,14 @@ export function buildJarvisAnswerEnvelope(input) {
     const turnId = input.traceId ?? null;
     if (!turnId)
         reasons.push("no_turn_id");
+    const sent = doorSources(input.sources);
     return {
         ok: true,
         answer: input.reply,
-        sources: extractSourceLines(input.reply),
+        // BLI-3770: the door's own citations when it sent them, and only then the
+        // prose fallback. Never both — a turn's receipts have one origin, and
+        // merging the two would double-count the lines the door already described.
+        sources: sent.length > 0 ? sent : sourcesFromAnswer(input.reply),
         turn_id: turnId,
         thread_id: input.thread ?? null,
         trace_thread_id: input.traceThread ?? null,

package/dist/commands/jarvis-turn.js

@@ -158,6 +158,10 @@ export async function sendOneTurn(context, prompt, io) {
                 revised: body.revised,
                 trace,
                 proposalId: body.proposalId,
+                // BLI-3770: the door's own structured citations. Absent from a
+                // dashboard that predates it, and the envelope falls back to
+                // reading the answer's own `Source:` lines when it is.
+                sources: body.sources,
             }),
             reply: body.reply,
             thread: body.thread ?? context.command.thread,

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

@@ -195,6 +195,10 @@ export function localSubcommandHelp(command) {
                 "",
                 "Starts collecting your work in the background. If you point it at a parent folder it covers every repo inside.",
                 "Add --ticket only when the work already has a visible ticket; omit it to preserve an existing binding.",
+                "--ticket takes EITHER tracker's id while both are running: a Tower issue (BLI-10000 and up, `cockpit issue list`)",
+                "or a Linear ticket. Tower is asked which row the id names, and the context records both ids when a row proves the pair —",
+                "a Tower-native issue whose title ends in `[BLI-3779]` mirrors that Linear ticket. An id Tower cannot place still binds:",
+                "the reason is printed, and the session is never held up by a tracker lookup.",
                 "Use --clear-ticket to go back to collecting general work with no ticket attached.",
                 "Use --topic/--intent/--phase for planning, discovery, and learning work that has no ticket yet.",
                 "Supported intents: implementation, bug_fix, root_cause_analysis, planning, discovery, review, testing, documentation, release, learning, coordination, maintenance, analysis, unknown, other.",

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.63");
+    writeLine(io?.stdout ?? process.stdout, "0.2.65");
     return 0;
   }
 

package/dist/commands/start-ticket-binding.js

@@ -0,0 +1,233 @@
+/**
+ * WHICH TICKET IS THIS, IN BOTH TRACKERS (BLI-3779).
+ *
+ * Tower runs its own issue tracker beside Linear during the dual-run, and one
+ * piece of work has an id in each: a Tower-native row (`BLI-10019`) whose
+ * title ends with the Linear id it mirrors (`… [BLI-3779]`). Before this
+ * module `cockpit start --ticket` recorded the string a person typed and
+ * nothing else, so a session bound to `BLI-3779` was invisible to every reader
+ * that keys on `work_issues`, and one bound to a Tower-native id resolved to
+ * nothing at all.
+ *
+ * This asks TOWER — through `GET /api/work/issues/<id>` and its `mirrors=`
+ * filter, the same doors `cockpit issue` uses — and hands `start.ts` both ids
+ * to record beside the one that was typed.
+ *
+ * Three rules it does not break:
+ *
+ *  - **Nothing blocks the session.** The session-first commandment applies to
+ *    a ticket lookup exactly as it does to attribution: an unpaired machine,
+ *    an unreachable Tower, a typo, an id no tracker has — every one of them
+ *    returns a NAMED outcome and `cockpit start` binds the context anyway.
+ *    This module never throws.
+ *  - **Only what a row proved is recorded.** A Tower id comes from a row that
+ *    was read; a Linear id comes from that row's title or from the imported
+ *    row's own identifier. Nothing is inferred from the number alone, and two
+ *    Tower rows mirroring one Linear id record NEITHER — `ambiguous` is the
+ *    `person-identity.ts` answer, and guessing binds a session to the wrong
+ *    ticket.
+ *  - **`active_ticket_id` stays exactly what was typed.** Rewriting it to the
+ *    resolved id would move every downstream attribution — the ambient
+ *    envelope, the ladder's per-ticket rung — onto an id nobody bound.
+ *
+ * One deployment hazard is handled on purpose: a laptop on a NEW CLI may talk
+ * to an OLDER dashboard that does not know the `mirrors=` filter and would
+ * answer the unfiltered list. Every returned row is therefore re-checked
+ * against the title convention here, and the request carries a small `limit`,
+ * so an old server can never make this bind to a row that mirrors something
+ * else. What it CAN cost is completeness, and the live probe on 2026-09-05
+ * showed both halves: against production-before-this-route the page happened
+ * to contain the right mirror (bound correctly), while a SECOND mirror of the
+ * same ticket sat outside the page and the ambiguity went unseen. Once the
+ * door ships, the filter is the server's and the answer is the whole set.
+ */
+import { isTowerNativeIssueId, mirroredTicketIdInTitle, normalizeIssueIdentifier, } from "@bli-cockpit/telemetry-core";
+import { askAgentDoor, openAgentDoor } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+const TAG = "[start ticket]";
+/** `cockpit start` must not stall on a tracker: two short reads at most. */
+export const TICKET_LOOKUP_DEADLINE_MS = 8_000;
+/** How many mirror candidates are worth naming before the answer is "several". */
+const MIRROR_CANDIDATE_LIMIT = 5;
+/**
+ * Asks Tower which issue a `--ticket` value names (named for the question it
+ * asks, not for the field it fills — `local-state-work-context.ts` has its own
+ * private `resolveTicketBinding`, which decides bind-vs-clear-vs-carry).
+ * Never throws; the caller binds the work context whatever comes back.
+ */
+export async function lookUpTicketInTower(ticketId, options) {
+    const identifier = normalizeIssueIdentifier(ticketId);
+    if (!identifier) {
+        return log({
+            ticket_id: ticketId,
+            status: "not_checked",
+            reason: "not_an_issue_identifier",
+            detail: `"${ticketId}" is not an identifier like BLI-3779, so no tracker was asked. The work context is bound to it as typed.`,
+        }, options.io);
+    }
+    let door;
+    try {
+        door = await openAgentDoor("start", { homeDir: options.homeDir, dashboardUrl: options.dashboardUrl, json: true }, options.io);
+    }
+    catch {
+        return log({
+            ticket_id: ticketId,
+            status: "not_checked",
+            reason: "collector_not_paired",
+            detail: `This machine has no Tower session, so ${identifier} was not looked up. Run \`cockpit login\` to bind tickets to Tower issues; the work context is bound either way.`,
+        }, options.io);
+    }
+    try {
+        const binding = isTowerNativeIssueId(identifier)
+            ? await resolveTowerNative(door, ticketId, identifier)
+            : await resolveLinearShaped(door, ticketId, identifier);
+        return log(binding, options.io);
+    }
+    catch (error) {
+        // A lookup must never take the session down with it.
+        return log({
+            ticket_id: ticketId,
+            status: "not_checked",
+            reason: "tower_unreachable",
+            detail: `Tower could not be asked about ${identifier} (${error instanceof Error ? error.name : "unknown error"}). The work context is bound to it as typed.`,
+        }, options.io);
+    }
+}
+/**
+ * An id at or above the Tower floor: only Tower's own tracker could have
+ * minted it, so one read decides it and Linear is not in the question.
+ */
+async function resolveTowerNative(door, ticketId, identifier) {
+    const found = await readIssue(door, identifier);
+    if (found.status === "failed")
+        return doorRefusal(ticketId, identifier, found.reason);
+    if (found.status === "missing") {
+        return {
+            ticket_id: ticketId,
+            status: "unresolved",
+            reason: "ticket_not_found_in_tower",
+            detail: `Tower has no issue ${identifier} (or you cannot read it). That number is in the range Tower mints, so Linear cannot hold it either. The work context is bound to it as typed.`,
+        };
+    }
+    const linear = mirroredTicketIdInTitle(found.issue.title);
+    return {
+        ticket_id: ticketId,
+        tower_issue_id: found.issue.identifier,
+        ...(linear ? { linear_ticket_id: linear } : {}),
+        status: linear ? "tower_mirrors_linear" : "tower_native",
+        detail: linear
+            ? `Bound to Tower issue ${found.issue.identifier}, which mirrors ${linear}.`
+            : `Bound to Tower issue ${found.issue.identifier}.`,
+    };
+}
+/**
+ * An id below the Tower floor belongs to Linear's range. Two reads, in this
+ * order:
+ *
+ *  1. the Tower-NATIVE row that mirrors it (`… [BLI-3779]`) — the row a person
+ *     actually works in during the dual-run, per Edward's 2026-09-05 order;
+ *  2. failing that, a row carrying the identifier itself, which is what the
+ *     Linear import writes (`work_issues.source = 'linear'`).
+ */
+async function resolveLinearShaped(door, ticketId, identifier) {
+    const mirrors = await readMirrors(door, identifier);
+    if (mirrors.status === "failed")
+        return doorRefusal(ticketId, identifier, mirrors.reason);
+    if (mirrors.issues.length === 1) {
+        const mirror = mirrors.issues[0];
+        return {
+            ticket_id: ticketId,
+            tower_issue_id: mirror.identifier,
+            linear_ticket_id: identifier,
+            status: "tower_mirrors_linear",
+            detail: `Bound to ${identifier} and to Tower issue ${mirror.identifier}, which mirrors it.`,
+        };
+    }
+    if (mirrors.issues.length > 1) {
+        const candidates = mirrors.issues.map((issue) => issue.identifier);
+        return {
+            ticket_id: ticketId,
+            linear_ticket_id: identifier,
+            status: "linear_only",
+            reason: "ambiguous_tower_mirror",
+            candidates,
+            detail: `${candidates.length} Tower issues mirror ${identifier} (${candidates.join(", ")}), so none was chosen — pass the one you mean to \`cockpit start --ticket\`. The context is bound to ${identifier}.`,
+        };
+    }
+    const imported = await readIssue(door, identifier);
+    if (imported.status === "failed")
+        return doorRefusal(ticketId, identifier, imported.reason);
+    if (imported.status === "found") {
+        return {
+            ticket_id: ticketId,
+            tower_issue_id: imported.issue.identifier,
+            linear_ticket_id: identifier,
+            status: "tower_mirrors_linear",
+            detail: `Bound to ${identifier}, which Tower holds under the same identifier.`,
+        };
+    }
+    return {
+        ticket_id: ticketId,
+        status: "unresolved",
+        reason: "ticket_not_found_in_linear",
+        detail: `Tower has no row for ${identifier} and no Tower issue mirrors it — Linear itself was not asked, so this says the mirror is missing, not that the ticket is. The work context is bound to it as typed.`,
+    };
+}
+function doorRefusal(ticketId, identifier, reason) {
+    return {
+        ticket_id: ticketId,
+        status: "not_checked",
+        reason: "tower_unreachable",
+        door_reason: reason,
+        detail: `Tower could not answer about ${identifier} (${reason}). The work context is bound to it as typed.`,
+    };
+}
+/** One issue by identifier. A 404 is an ANSWER, not a failure. */
+async function readIssue(door, identifier) {
+    const answer = await askAgentDoor(door, {
+        path: `/api/work/issues/${encodeURIComponent(identifier)}`,
+        method: "GET",
+        label: "start ticket read",
+        timeoutMs: TICKET_LOOKUP_DEADLINE_MS,
+    });
+    if (!answer.ok) {
+        if (answer.httpStatus === 404)
+            return { status: "missing" };
+        return { status: "failed", reason: answer.reason };
+    }
+    const issue = answer.body.issue;
+    return issue ? { status: "found", issue } : { status: "missing" };
+}
+/**
+ * The Tower rows whose title carries `[<identifier>]`. The server filters, and
+ * the answer is checked against the same convention here — an older dashboard
+ * that ignores `mirrors=` returns an unfiltered page, and accepting it would
+ * bind the session to a row that mirrors nothing.
+ */
+async function readMirrors(door, identifier) {
+    const answer = await askAgentDoor(door, {
+        path: `/api/work/issues?mirrors=${encodeURIComponent(identifier)}&limit=${MIRROR_CANDIDATE_LIMIT}`,
+        method: "GET",
+        label: "start ticket mirrors",
+        timeoutMs: TICKET_LOOKUP_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return { status: "failed", reason: answer.reason };
+    const issues = answer.body.issues ?? [];
+    return {
+        status: "ok",
+        issues: issues.filter((issue) => mirroredTicketIdInTitle(issue.title ?? "") === identifier),
+    };
+}
+/** Every outcome, success included — ids and labels only, never a title. */
+function log(binding, io) {
+    writeLine(io.stderr, `${TAG} resolved ${JSON.stringify({
+        status: binding.status,
+        reason: binding.reason ?? null,
+        door_reason: binding.door_reason ?? null,
+        tower_issue_id: binding.tower_issue_id ?? null,
+        linear_ticket_id: binding.linear_ticket_id ?? null,
+        candidates: binding.candidates?.length ?? 0,
+    })}`);
+    return binding;
+}

package/dist/commands/start.js

@@ -1,8 +1,16 @@
 import { writeLine } from "./cli-io.js";
 import { displayTicketId } from "./collection-report.js";
 import { discoverCommandWorktrees } from "./local-discovery.js";
+import { lookUpTicketInTower } from "./start-ticket-binding.js";
 import { startLocalWorkContext } from "../local-state.js";
 export async function runStart(command, io) {
+    const binding = command.activeTicketId
+        ? await lookUpTicketInTower(command.activeTicketId, { homeDir: command.homeDir, io })
+        : null;
+    const ticketIds = {
+        towerIssueId: binding?.tower_issue_id,
+        linearTicketId: binding?.linear_ticket_id,
+    };
     const worktrees = await discoverCommandWorktrees(command.repoRoot, { maxDepth: command.maxDepth, maxRepos: command.maxRepos, homeDir: command.homeDir }, io);
     if (worktrees.length > 1) {
         const contexts = await Promise.all(worktrees.map((worktree) => startLocalWorkContext({
@@ -10,6 +18,7 @@ export async function runStart(command, io) {
             repoRoot: worktree.repo_root,
             branch: command.branch,
             activeTicketId: command.activeTicketId,
+            ...ticketIds,
             clearTicket: command.clearTicket,
             topicLabel: command.topicLabel,
             topicSummaryRedacted: command.topicSummaryRedacted,
@@ -21,27 +30,47 @@ export async function runStart(command, io) {
             sessionId: command.sessionId,
         })));
         if (command.json) {
-            writeLine(io.stdout, JSON.stringify({ mode: "multi_repo", contexts }, null, 2));
+            writeLine(io.stdout, JSON.stringify({ mode: "multi_repo", contexts, ...(binding ? { ticket_binding: binding } : {}) }, null, 2));
             return 0;
         }
         writeLine(io.stdout, `Tower parent work context active for ${contexts.length} worktree(s).`);
         for (const context of contexts) {
             writeLine(io.stdout, `- ${context.repo_label ?? context.repo}/${context.worktree_label ?? "worktree"} · ${context.branch} · ${context.work_context_id}`);
         }
+        writeTicketLines(io, binding);
         return 0;
     }
-    const context = await startLocalWorkContext(command);
+    const context = await startLocalWorkContext({ ...command, ...ticketIds });
     if (command.json) {
-        writeLine(io.stdout, JSON.stringify(context, null, 2));
+        writeLine(io.stdout, JSON.stringify({ ...context, ...(binding ? { ticket_binding: binding } : {}) }, null, 2));
         return 0;
     }
     writeLine(io.stdout, "Tower work context active.");
     writeLine(io.stdout, `Repo: ${context.repo}`);
     writeLine(io.stdout, `Branch: ${context.branch}`);
     writeLine(io.stdout, `Ticket: ${displayTicketId(context.active_ticket_id)}`);
+    writeTicketLines(io, binding, context.tower_issue_id, context.linear_ticket_id);
     if (context.topic_label || context.work_intent || context.work_phase) {
         writeLine(io.stdout, `Topic: ${context.topic_label ?? "unlabeled"} · ${context.work_intent ?? "unknown"} · ${context.work_phase ?? "unknown"}`);
     }
     writeLine(io.stdout, `Context: ${context.work_context_id}`);
     return 0;
+}
+/**
+ * Both trackers' ids when they are known, and the reason when one is not. A
+ * lookup that resolved nothing still prints its sentence: a person who typed
+ * a ticket id deserves to know Tower could not place it, and silence there is
+ * exactly the "green status hiding a gap" this repo forbids.
+ */
+function writeTicketLines(io, binding, towerIssueId, linearTicketId) {
+    if (!binding)
+        return;
+    const tower = towerIssueId ?? binding.tower_issue_id;
+    const linear = linearTicketId ?? binding.linear_ticket_id;
+    if (tower)
+        writeLine(io.stdout, `Tower issue: ${tower}`);
+    if (linear)
+        writeLine(io.stdout, `Linear: ${linear}`);
+    if (!tower || !linear)
+        writeLine(io.stdout, binding.detail);
 }

package/dist/commands/status.js

@@ -66,6 +66,12 @@ export async function runStatus(command, io) {
     writeLine(io.stdout, `Repo: ${status.repo}`);
     writeLine(io.stdout, `Branch: ${status.branch}`);
     writeLine(io.stdout, `Ticket: ${displayTicketId(status.active_ticket_id)}`);
+    // BLI-3779: one ticket, two trackers. Each line appears only when a row
+    // proved it — an absent line means "not resolved", never "does not exist".
+    if (status.tower_issue_id)
+        writeLine(io.stdout, `Tower issue: ${status.tower_issue_id}`);
+    if (status.linear_ticket_id)
+        writeLine(io.stdout, `Linear: ${status.linear_ticket_id}`);
     writeLine(io.stdout, `Work: ${displayWorkLabel(status)}`);
     writeLine(io.stdout, `Last collected: ${lastCollectedLine(status.collector_freshness)}`);
     writeLine(io.stdout, `Version: ${status.collector_version}`);

package/dist/local-state-status.js

@@ -30,6 +30,8 @@ export async function inspectLocalCollectorStatus(options = {}) {
         repo: context?.repo ?? identity.repo_root,
         branch,
         active_ticket_id: context?.active_ticket_id ?? null,
+        tower_issue_id: context?.tower_issue_id ?? null,
+        linear_ticket_id: context?.linear_ticket_id ?? null,
         work_label: context ? workDisplayLabel(context) : null,
         work_id: context?.work_context_id ?? null,
         work_context_id: context?.work_context_id ?? null,

package/dist/local-state-work-context.js

@@ -73,7 +73,7 @@ async function writeLocalWorkContext(options, attributedIdentity) {
  */
 function buildWorkContext(input) {
     const { options, now, identity, branch, operatorId, sessionId, workContextId, existingContext } = input;
-    const { activeTicketId, ticketBindingCandidates } = resolveTicketBinding(options, existingContext);
+    const { activeTicketId, towerIssueId, linearTicketId, ticketBindingCandidates } = resolveTicketBinding(options, existingContext);
     return LocalWorkContextSchema.parse({
         work_context_id: workContextId,
         repo: identity.repo_root,
@@ -90,6 +90,8 @@ function buildWorkContext(input) {
         started_at: existingContext?.started_at ?? now.toISOString(),
         updated_at: now.toISOString(),
         active_ticket_id: activeTicketId,
+        tower_issue_id: towerIssueId,
+        linear_ticket_id: linearTicketId,
         ticket_binding_candidates: ticketBindingCandidates,
         topic_label: options.topicLabel,
         topic_summary_redacted: options.topicSummaryRedacted,
@@ -119,6 +121,12 @@ function buildWorkContext(input) {
 /**
  * Three answers, not two: a named ticket binds, `--clear-ticket` unbinds, and
  * saying neither leaves whatever the previous `cockpit start` bound in place.
+ *
+ * The other tracker's ids (BLI-3779) follow the SAME three answers, and they
+ * follow the TYPED ticket rather than each other: naming a ticket replaces
+ * them with whatever this run resolved — including with nothing, when the
+ * lookup came back unresolved — because carrying the previous ticket's Tower
+ * id onto a new one would attribute this session's work to the last ticket.
  */
 // The return type is inferred deliberately: naming it would mean indexing the
 // context schema by field name, and this module keeps its literals to the ones
@@ -127,6 +135,9 @@ function resolveTicketBinding(options, existingContext) {
     const activeTicketId = options.clearTicket
         ? undefined
         : (options.activeTicketId ?? existingContext?.active_ticket_id);
+    const rebinding = Boolean(options.clearTicket || options.activeTicketId);
+    const towerIssueId = rebinding ? options.towerIssueId : existingContext?.tower_issue_id;
+    const linearTicketId = rebinding ? options.linearTicketId : existingContext?.linear_ticket_id;
     const ticketBindingCandidates = options.activeTicketId
         ? [
             {
@@ -139,7 +150,7 @@ function resolveTicketBinding(options, existingContext) {
         : options.clearTicket
             ? []
             : (existingContext?.ticket_binding_candidates ?? []);
-    return { activeTicketId, ticketBindingCandidates };
+    return { activeTicketId, towerIssueId, linearTicketId, ticketBindingCandidates };
 }
 /** The active context: what the last `cockpit start` on this machine bound, whatever the folder. */
 export async function readLocalWorkContext(paths) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.63",
+  "version": "0.2.65",
   "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-runtime-files.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.8",
-    "@bli-cockpit/mcp": "0.1.6",
-    "@bli-cockpit/telemetry-core": "0.1.29"
+    "@bli-cockpit/memory-mcp": "0.1.9",
+    "@bli-cockpit/mcp": "0.1.8",
+    "@bli-cockpit/telemetry-core": "0.1.30"
   }
 }