@bli-cockpit/cli 0.2.292 → 0.2.294

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

@@ -7,6 +7,7 @@
  * address they have always had.
  */
 import { optionalNonEmpty, optionalPositiveInteger, optionalUrl, parseNamedArgs, } from "./local-arg-values.js";
+import { readNotesCorrection, readNotesShelfTarget } from "./local-args-notes-targets.js";
 /**
  * The notetakers `cockpit notes connect` will actually seal a key for
  * (BLI-4391). It mirrors `CONNECTABLE_NOTES_PROVIDERS` in the dashboard, and
@@ -34,7 +35,7 @@ const NOTES_ACTIONS = new Set([
     "upload",
     "paste",
     "share",
-    "unshare",
+    "unshare", "correct",
     "summarize",
     "move",
     "place",
@@ -61,7 +62,7 @@ const NOTES_ACTIONS = new Set([
 const NOTES_ACTIONS_NEEDING_A_NOTE = new Set([
     "show",
     "share",
-    "unshare",
+    "unshare", "correct",
     "summarize",
     "move",
     "place",
@@ -82,7 +83,7 @@ const NOTES_ALLOWED_FLAGS = [
     "--file",
     "--name",
     "--exclude",
-    "--to",
+    "--to", "--from", "--transcript", // BLI-24437: `correct <id> --from <term> --to <term> [--transcript]`
     "--folder",
     "--clear-shelf",
     "--apply",
@@ -122,7 +123,7 @@ const NOTES_VALUE_FLAGS = [
     "--file",
     "--name",
     "--exclude",
-    "--to",
+    "--to", "--from",
     "--folder",
     "--series",
     "--kind",
@@ -180,6 +181,7 @@ export function parseNotesArgs(args) {
         exclude: optionalNonEmpty(values.flags.get("--exclude")),
         ...(to ? { to } : {}),
         ...(clearShelf ? { clearShelf } : {}),
+        ...readNotesCorrection(action, values),
         // BLI-4058. `place` says where a note belongs; only `--apply` moves it.
         ...(values.booleans.has("--apply") ? { apply: true } : {}),
         series: optionalNonEmpty(values.flags.get("--series")),
@@ -201,7 +203,7 @@ function readNotesAction(first) {
     // almost always wants — same reasoning as bare `cockpit` running convergence.
     const action = (first === undefined ? "list" : first);
     if (!NOTES_ACTIONS.has(action)) {
-        throw new Error(`Unknown notes command: ${first}. Try list, show, shelf, shelves, upload, paste, share, unshare, summarize, move, place, accounts, connect, detach, sync, sync-status, recordings, recording, webhook, granola-status, transcription-stats, or review (and record start|stop|status|cancel, app install|uninstall|status).`);
+        throw new Error(`Unknown notes command: ${first}. Try list, show, shelf, shelves, upload, paste, share, unshare, correct, summarize, move, place, accounts, connect, detach, sync, sync-status, recordings, recording, webhook, granola-status, transcription-stats, or review (and record start|stop|status|cancel, app install|uninstall|status).`);
     }
     return action;
 }
@@ -368,19 +370,6 @@ function readNotesPaths(action, rest) {
     }
     return undefined;
 }
-function readNotesShelfTarget(action, values) {
-    const to = optionalNonEmpty(values.flags.get("--to"));
-    const clearShelf = values.booleans.has("--clear-shelf");
-    if (action !== "move")
-        return { to, clearShelf };
-    if (to && clearShelf) {
-        throw new Error("notes move accepts either --to or --clear-shelf, not both.");
-    }
-    if (!to && !clearShelf && !values.flags.get("--folder")) {
-        throw new Error('notes move needs --to "<shelf>", --clear-shelf, or --folder "<path>".');
-    }
-    return { to, clearShelf };
-}
 function readNotesMonth(action, values) {
     const month = optionalNonEmpty(values.flags.get("--month"));
     if (month === undefined)

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

@@ -112,7 +112,7 @@ export const TOWER_COMMAND_HELP = [
             "dm <email> [<email>...] — with several addresses, opens (or re-opens) the group message with exactly those people plus you; the same set always resolves to the same channel. channel <channel> [--json] — the channel's details: name, description, kind, archived, audience (a public channel is everyone in the org, not a member count), source workspace label (where it came from; it grants no access), whether you can manage it, and whether you hid it. channel <channel> --rename <name> | --describe <text> | --archive | --unarchive — changes it (one update; --rename and --describe can go together). Only the person who made the channel, its owners and its moderators can; anyone else is refused channel_manage_refused, a name in use channel_name_taken, a direct message dm_not_editable. Archiving keeps every message and link and stops new posts (channel_archived); unarchive restores posting. members <channel> [--json] — who is in a private channel or a direct message; a public channel says everyone in the org can read it. members <channel> --add <email> | --remove <email> — private channels only, by the same people who can manage it; a removed person's next read is refused. A direct message keeps the people it started with (dm_not_editable): start a new group with `msg dm a@x b@y`. hide <channel> / unhide <channel> — drops a PUBLIC channel from your own sidebar, or puts it back; it changes nothing for anyone else and nothing about reading, search, mentions or notifications. A private channel or direct message is refused hide_not_public.",
             "read <channel> [--limit <n>] [--thread <id>] [--mark-read] — the channel's most recent top-level messages, oldest first; --thread <id> reads one thread's replies instead. The first page also says where the messages come from (for an imported Slack channel: how long ago the archive was checked, or that it is unknown) and where YOUR read line stands. Reading never moves the read line; --mark-read moves it to the newest message shown, and says plainly if that failed.",
             "unread <channel> --from <message-id> — marks that message and everything after it unread, so the web sidebar badge and the NEW MESSAGES line start there. Opening or reading a channel never clears unseen history.",
-            "send <channel> [--thread <id>] [--request-id <uuid>] — posts a message. The content is never accepted on the command line: pipe it in, e.g. `echo \"hello\" | cockpit msg send general`. Every send carries a request id (minted when you give none); retry a send whose answer was lost with the SAME --request-id and the same text and it posts once. The same id with different text is refused request_id_reused, not applied as an edit. send <channel> --file <id> [--file <id>...] — attaches up to 10 ready files (from `msg file upload`) to the message. The text is optional with a file; it is read from stdin only when something is piped in. file upload <channel> <path|-> [--name <name>] — uploads a file of 1 byte to 25 MB straight to storage (reserve, PUT, finalize) and prints its id and state; `-` reads stdin and needs --name. A file is ready, not sent: attach it with `msg send <channel> --file <id>`. file show <id> — the descriptor (state reserved, ready, attached, cancelled or abandoned). file download <id> [--out <path>] — saves the bytes (60-second signed link; never overwrites). file cancel <id> — ends an unattached file and removes its bytes. file list <channel> — your own unsent uploads there, with coverage. A file is readable only by readers of its channel, and only once attached to a live message. Refusals keep the door's reason: file_too_large, file_not_found_or_unreadable, file_not_uploaded, file_not_ready, file_already_attached, file_wrong_channel, storage_unreachable.",
+            "send <channel> [--thread <id>] [--request-id <uuid>] — posts a message. The content is never accepted on the command line: pipe it in, e.g. `echo \"hello\" | cockpit msg send general`. Every send carries a request id (minted when you give none); retry a send whose answer was lost with the SAME --request-id and the same text and it posts once. The same id with different text is refused request_id_reused, not applied as an edit. send <channel> --file <id> [--file <id>...] — attaches up to 10 ready files (from `msg file upload`) to the message. The text is optional with a file; it is read from stdin only when something is piped in. file upload <channel> <path|-> [--name <name>] — uploads a file of 1 byte to 25 MB straight to storage (reserve, PUT, finalize) and prints its id and state; `-` reads stdin and needs --name. A file is ready, not sent: attach it with `msg send <channel> --file <id>`. file show <id> — the descriptor (state reserved, ready, attached, cancelled or abandoned). file download <id> [--out <path>] — saves the bytes (60-second signed link; never overwrites). file cancel <id> — ends an unattached file and removes its bytes. file list <channel> — your own unsent uploads there, with coverage. A file is readable only by readers of its channel, and only once attached to a live message. Refusals keep the door's reason: file_too_large, file_not_found_or_unreadable, file_not_uploaded, file_not_ready, file_already_attached, file_wrong_channel, storage_unreachable (no answer: try again), storage_refused (storage said no: retrying will not help; the sentence names the step, HTTP status and class).",
             "edit <message-id> [--expected-revision <n>] [--request-id <uuid>] — replaces your own message's text (piped in). With --expected-revision, an edit of a message that has moved on is refused revision_conflict and nothing is saved over it; the current revision is printed. A message you did not write, or one that was deleted, is refused by name. delete <message-id> [--expected-revision <n>] [--request-id <uuid>] — deletes by tombstone: the text is cleared and every surface reads \"This message was deleted\", but the row stays so its thread, replies and reply count survive. Search and unread counts ignore it. A repeat answers already_deleted. outcome <request-uuid> — your own write receipt for a send, edit or delete: committed, not_committed (with the reason) or unknown_check_again. Run it after a timeout before retrying. draft [list|show|save|discard|restore|send] <channel> [--thread <id>] [--expected-revision <n>] [--request-id <uuid>] — the text you have not sent yet, one draft per channel and thread, the same drafts the browser autosaves. list shows all your unsent drafts (newest first, with coverage); show prints one; save takes the body on stdin (`echo \"half a thought\" | cockpit msg draft save general`) and with --expected-revision refuses draft_revision_conflict, naming the stored revision, instead of overwriting; discard keeps the text (state discarded) and restore brings it back; send posts the stored draft with a fresh request id (--request-id to retry the same send) and its revision, prints the receipt, and marks the draft sent only if it did not change meanwhile. Only you can read or change your drafts.",
             "thread <id> --channel <channel> [--before <cursor>] [--limit <n>] — one thread's replies by the parent message's id.",
             "show <message-id> — exact message, thread root and bounded neighbors. read/thread --before takes the preceding nextCursor; repeat until hasMore is false. activity [--mentions|--threads] [--unread] [--before <cursor>] [--limit <n>] [--mark-read] — your Mentions (messages that mention you) and Threads (replies in threads you follow: you started it, replied natively or followed it by hand), newest first, with unread counts and coverage; items whose message you can no longer read are left out and counted as dropped. Nothing is marked read by looking; --mark-read marks the unread items just printed, and the web marks one when its message is shown. Activity covers native Tower messages only, so the Slack import adds none. follow <message-id> / unfollow <message-id> — the id is the thread's top-level message; an explicit unfollow wins over a later auto follow, and earlier items stay. react <message-id> <emoji> [--remove] — adds or takes off your reaction (idempotent). Refusals: thread_root_not_found_or_unreadable, not_a_thread_root, reaction_not_found. notify — your message notification settings (the same ones the web header menu and Settings change): the default level (all, mentions or none; mentions is the default and covers direct messages, @mentions and replies in threads you follow), quiet hours and per-channel overrides. notify set --level <all|mentions|none> changes the default; add --channel <id|name> for one channel, with --mute / --unmute, or --clear to remove the override. notify quiet <HH:MM-HH:MM> [--timezone <zone>] sets quiet hours (24-hour, may wrap midnight; the zone defaults to this machine's) and notify quiet --off removes them. notify receipts [--message <id>] [--before <cursor>] [--limit <n>] lists what was delivered, suppressed or blocked and why (never message text): outcome shown means Tower told a browser tab to show a banner; push_accepted means the push service took the phone push, not that a phone showed it. Quiet hours and levels hold back banners and phone pushes, never the message or its unread badge. Refusals: invalid_notification_level, invalid_quiet_hours, invalid_timezone. search [words] [--from <email|me>]... [--in <channel>] [--since YYYY-MM-DD] [--until YYYY-MM-DD] [--timezone <IANA>] [--replies|--top-level] [--has-file] [--before <cursor>] [--limit <n>] — message search on your own access, newest first (not ranked; `cockpit search --kind msg` is the ranked bar). Each hit prints its id, channel, author, time and snippet, then `more: --before <cursor>` or `complete`; repeat with the cursor until complete. --from takes an email, a user id or me and repeats; --in takes a channel id or #name (exact after case folding, an ambiguous name is refused); --since and --until are whole local days in --timezone, both inclusive (this machine's zone when you give none). The words may be left out when a filter is set, so `msg search --has-file` finds attachment-only messages. Inline operators work in the words as in the web box: from:<email|me> in:#name after:<day> before:<day> (exclusive) on:<day> has:file is:reply is:root. Recognised but unsupported operators (has:link, has:pin, has:reaction, is:saved, is:dm, to:, with:, during:) are refused unsupported_search_operator, naming the operator; a bad day, zone, person or channel is refused invalid_search_filter. Messages imported from Slack carry no file links, so has:file does not find them. Deleted messages, channels you cannot read and files you cannot read never appear.",
@@ -251,7 +251,7 @@ export const TOWER_COMMAND_HELP = [
         "usage",
         [
             "Usage: cockpit usage people [--by-repo | --by-topic | --by-subject | --by-task | --by-client] [--min-confidence high|medium|low] [--person <email|me>] [--all] [--since <n>d|<n>h|<iso>] [--detail] [--until <iso>] [--include-automated] [--json]",
-            "  cockpit usage sessions [--person <exact-name>] [--task <BLI-NNNN> | --subject <name>] [--repo <label>] [--tool claude|codex] [--since <window>] [--until <iso>] [--cursor <cursor>] [--limit <n>] [--json]",
+            "  cockpit usage sessions [--person <exact-name>] [--task <BLI-NNNN> | --subject <name>] [--repo <label>] [--tool claude|codex|opencode] [--since <window>] [--until <iso>] [--cursor <cursor>] [--limit <n>] [--json]",
             "  cockpit usage session <id> [--from-window <n>] [--json]",
             "  --by-topic groups work types; --by-subject groups open subjects from session summaries.",
             "",

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

@@ -3,7 +3,7 @@ export const NOTES_HELP = [
     [
         "notes",
         [
-            "Usage: cockpit notes [list|show <id>|shelf|shelves|folders|mkdir <path>|rmdir <path>|rename <path>|upload <paths...> [--wait]|paste|share <id>|unshare <id>|summarize <id>|move <id>|accounts|connect|detach <id>|sync <id>|sync-status [<id>]|recordings <note-id>|recording <id>|record start|stop|status|cancel|app install|uninstall|status|review [<note-id>] [--submit|--accept-all]] [flags]",
+            "Usage: cockpit notes [list|show <id>|shelf|shelves|folders|mkdir <path>|rmdir <path>|rename <path>|upload <paths...> [--wait]|paste|share <id>|unshare <id>|correct <id> --from <term> --to <term>|summarize <id>|move <id>|accounts|connect|detach <id>|sync <id>|sync-status [<id>]|recordings <note-id>|recording <id>|record start|stop|status|cancel|app install|uninstall|status|review [<note-id>] [--submit|--accept-all]] [flags]",
             "Audio uploads: MP3, M4A, WAV, WebM and OGG, up to 1 GB. Over 4 MB (a whole meeting) the file goes straight to storage and is transcribed in the background; --wait then polls for up to 4 hours and prints progress, otherwise for at most 330 seconds.",
             "",
             "record start|stop [<session-id>]|status|cancel — record a meeting in a room from this machine's microphone (Apple Silicon macOS and Windows; Linux says it is not supported). On Windows the microphone needs Settings > Privacy & security > Microphone on, including Let desktop apps access your microphone. Nothing leaves the machine while recording; the recorder stops by itself after 8 hours (under the 1 GB upload limit). `stop` uploads the whole original recording, silence included, and Tower writes a note with Speaker 1, Speaker 2... lines, or says no speech was detected (add --wait to watch the transcription). `cancel` stops and KEEPS the file; `status` lists what is recording and every session waiting for upload (`needs_upload`); `stop <session-id>` uploads a cancelled, crashed or auto-stopped session. The BLI Notetaker app uploads waiting sessions by itself. The recording also stays on this machine.",
@@ -24,6 +24,7 @@ export const NOTES_HELP = [
             "share <id> [--yes] — let everyone signed in read the statements that are safe to share. Asks first in a terminal; --yes is required without one, and --json implies --yes.",
             "summarize <id> — write a new summary (decisions, action items, key points) where every claim cites the speaker, timestamp and segment id (s12) it came from; claims the transcript does not support are dropped. Takes up to a minute; earlier summaries are kept. `show <id>` prints the newest one.",
             "unshare <id> — take it back. Never asks: it only ever narrows who can read.",
+            "correct <id> --from \"<misheard>\" --to \"<right>\" [--transcript] — fix a misheard term: every whole-word mention in the note's notes and summary in one write, the previous text kept. The transcript stays as recorded unless you pass --transcript, and then each fix is marked beside the words as heard. Owner or admin only. Then `cockpit glossary add` makes future transcripts and incoming notes spell it right.",
             "move <id> (--to \"<shelf>\"|--clear-shelf) — put it on a different shelf, or take the shelf off.",
             "place <id> [--apply] — say which shelf this note belongs on and why, from the meeting it is part of, who was in the room and its own name. Moves nothing without --apply, and never overrules a shelf somebody typed.",
             "",

package/dist/commands/local-help.js

@@ -146,9 +146,9 @@ const COMMAND_SUMMARY_LINES = [
     "  cockpit correct --claim <claimId> --text \"<what is wrong>\" [--for <person>] [--version <pageId>] [--supersedes <id>] [--dashboard-url <url>] [--json]",
     "  cockpit notes [list|show <id>|shelf|shelves|folders|mkdir <path>|rmdir <path>|rename <path>|upload <paths...> [--wait]|paste|share <id>|unshare <id>|summarize <id>|move <id>|place <id>] [--folder <path>] [--series <shelf>] [--kind <kind>] [--since <YYYY-MM-DD>] [--until <YYYY-MM-DD>] [--limit <n>] [--file <path>] [--name <n>] [--exclude \"<sentence>\"] [--to \"<shelf>\"|--clear-shelf] [--apply] [--yes] [--dashboard-url <url>] [--json]",
     "  cockpit notes [accounts [--show-webhook <account-id>]|connect --provider fellow --workspace <sub> --key-stdin [--name <n>]|connect --provider wisprflow|recordings <note-id>|recording <id>|webhook <account-id> --secret-stdin|detach <account-id>|sync <account-id>] [--json]   (the key and the signing secret are read from stdin, never a flag)",
-    "  cockpit backfill (--since-days <n>|--all) [--source codex|claude] [--dry-run] [--max-files <n>] [--max-depth <n>] [--max-repos <n>] [--lock-wait <seconds>] [--yes] [--workspace <path>] [--json]",
+    "  cockpit backfill (--since-days <n>|--all) [--source codex|claude|opencode] [--dry-run] [--max-files <n>] [--max-depth <n>] [--max-repos <n>] [--lock-wait <seconds>] [--yes] [--workspace <path>] [--json]",
     "  cockpit status [--workspace <path>] [--max-depth <n>] [--max-repos <n>] [--json]",
-    "  cockpit sessions [--source codex|claude] [--since-days <n>|--all] [--workspace <path>] [--max-depth <n>] [--max-repos <n>] [--json]",
+    "  cockpit sessions [--source codex|claude|opencode] [--since-days <n>|--all] [--workspace <path>] [--max-depth <n>] [--max-repos <n>] [--json]",
     "  cockpit serve [--port <port>] [--workspace <path>]",
     "  cockpit autostart [install|uninstall|status] [--workspace <path>] [--dashboard-url <url>] [--interval-seconds <n>] [--json]",
     "  cockpit agent-rules [install|uninstall|status] [--host codex|claude|all] [--workspace <path>] [--json]",
@@ -190,7 +190,7 @@ const COMMAND_SUMMARY_LINES = [
     "  cockpit manager <clients|client <client>|run <run-id>|list <client>|queue <client>|show <id>|add <client> --title <t>|edit <id> --version <v>|done|reopen|link|approve|dismiss|proposal|archive|unarchive> [--timeline] [--dashboard-url <url>] [--json]",
     "  cockpit image <describe <file> [--session <id>]|show <sha256-or-prefix>> [--dashboard-url <url>] [--json]",
     "  cockpit setup [--since <duration|date>] [--until <date>] [--machines] [--details] [--person <name|email>] [--compare <name,name>] [--json]",
-    "  cockpit usage sessions [--person <exact-name>] [--task <BLI-NNNN> | --subject <name>] [--repo <label>] [--tool claude|codex] [--since <window>] [--until <iso>] [--cursor <cursor>] [--limit <n>] [--json]",
+    "  cockpit usage sessions [--person <exact-name>] [--task <BLI-NNNN> | --subject <name>] [--repo <label>] [--tool claude|codex|opencode] [--since <window>] [--until <iso>] [--cursor <cursor>] [--limit <n>] [--json]",
     "  cockpit usage session <id> [--from-window <n>] [--json]",
     "  --by-topic groups work types; --by-subject groups open subjects from session summaries.",
     "  cockpit ticket mutation-status <request-uuid> [--json] (check a lost write response)",

package/dist/commands/notes-writes.js

@@ -223,6 +223,30 @@ export async function shareNote(command, door) {
     sayUpload(door, body);
     return 0;
 }
+/**
+ * `cockpit notes correct <note-id> --from <term> --to <term> [--transcript]` (BLI-24437): one call to
+ * `POST /api/notes/correct`, the door the browser, MCP and JARVIS use. The server counts; this prints its sentences.
+ * A refusal, including "nothing_to_correct" (no mention found, nothing changed), prints the server's sentence and exits 1.
+ */
+export async function correctNote(command, door) {
+    const scope = command.transcript ? "notes_and_transcript" : "notes";
+    const answer = await ask(door, {
+        path: "/api/notes/correct",
+        method: "POST",
+        label: "notes correct",
+        timeoutMs: READ_DEADLINE_MS,
+        body: { note_id: command.noteId, from: command.from, to: command.to, scope },
+    });
+    if (!answer.ok) {
+        return fail(door, answer.reason, answer.detail);
+    }
+    const body = answer.body;
+    writeLine(door.io.stderr, `${TAG} corrected ${JSON.stringify({ note_id: command.noteId ?? null, scope, notes: body.counts?.notes ?? null, transcript: body.counts?.transcript ?? null, summary: body.counts?.summary ?? null })}`);
+    if (door.json)
+        return emit(door, body);
+    sayUpload(door, body);
+    return 0;
+}
 /** A summary run is two model calls over a long transcript: give it room (BLI-20882). */
 const SUMMARIZE_DEADLINE_MS = 330_000;
 /**

package/dist/commands/notes.js

@@ -48,7 +48,7 @@
 import os from "node:os";
 import { loadPairedSession } from "../tower-client.js";
 import { listNotes, listShelves, showNote, showShelf } from "./notes-reads.js";
-import { uploadNotes, pasteNote, shareNote, summarizeNote, moveNote, placeNote } from "./notes-writes.js";
+import { uploadNotes, pasteNote, shareNote, summarizeNote, moveNote, placeNote, correctNote } from "./notes-writes.js";
 import { runFolderCommand } from "./notes-folders.js";
 import { armNotesWebhook, connectNotetaker, detachNotetaker, listNotesAccounts, showNotesWebhook, syncNotetaker, syncStatusNotetakers, } from "./notes-accounts.js";
 import { showBotUpcoming } from "./notes-bot-upcoming.js";
@@ -60,7 +60,7 @@ import { defaultRecordDeps, runNotesRecord } from "./notes-record.js";
 import { runNotesApp } from "./notes-app.js";
 import { defaultExec, errorMessage } from "./cli-io.js";
 export { listNotes, listShelves, showNote, showShelf } from "./notes-reads.js";
-export { uploadNotes, pasteNote, shareNote, summarizeNote, moveNote, placeNote } from "./notes-writes.js";
+export { uploadNotes, pasteNote, shareNote, summarizeNote, moveNote, placeNote, correctNote } from "./notes-writes.js";
 export { armNotesWebhook, connectNotetaker, detachNotetaker, listNotesAccounts, showNotesWebhook, syncNotetaker, syncStatusNotetakers, } from "./notes-accounts.js";
 export { showGranolaStatus } from "./notes-granola-status.js";
 export { showTranscriptionStats } from "./notes-transcription-stats.js";
@@ -80,6 +80,7 @@ const NOTES_VERBS = {
     paste: pasteNote,
     share: shareNote,
     unshare: shareNote,
+    correct: correctNote,
     summarize: summarizeNote,
     move: moveNote,
     place: placeNote,

package/dist/commands/opencode-sync.js

@@ -0,0 +1,163 @@
+/** Route OpenCode's third native format through the existing evidence pack, spool, report queue and durable cursor. */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getCollectorRuntimePaths, readLocalCollectorConfig, readLocalCollectorSessionFile, startLocalWorkContext, startLocalWorkContextForAttributedTarget } from "../local-state.js";
+import { writeJsonFileAtomic } from "../local-state-files.js";
+import { reportShelvedSessions } from "../shelf-reports.js";
+import { openCodeCollectionPolicy } from "../opencode-policy.js";
+import { RAW_EVIDENCE_DEFAULT_BYTE_BUDGET, RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET } from "../adapters/raw-evidence.js";
+import { cwdInsideRoots } from "../collection-scope.js";
+import { scoreSignalsAgainstWorktrees, sha256 } from "../adapters/attribution-core.js";
+import { outsideRootsWorkspace, isOutsideRootsWorkspace } from "./backfill-outside-roots.js";
+import { syncLocalAmbientEnvelope } from "../upload.js";
+import { readRawEvidenceCursor, writeRawEvidenceCursor } from "../cursors/raw-evidence-cursor.js";
+import { readOpenCodeInventory, acknowledgeOpenCodeUsage, OPENCODE_CURSOR_FILENAME } from "../opencode-inventory.js";
+import { queueCodexSessionReport, flushPendingCodexSessionReports } from "../upload-session-reports.js";
+import { recordSourceRetryFailure, clearSourceRetryFailure } from "../spool/local-spool.js";
+import { describeError } from "../health-detail.js";
+/** The all-history inventory is resumable through existing per-object acknowledgments, never a second delivery engine. */
+export async function syncOpenCodeSessions(options) {
+    const paths = getCollectorRuntimePaths(options.homeDir);
+    const now = new Date();
+    const summary = { source: "opencode", new_since_last_scan: 0, outside_roots: 0, discovered: 0, eligible: 0, delivered: 0, pending: 0, withheld: 0, unique: 0, coverage: "complete", reasons: [] };
+    try {
+        const policy = await openCodeCollectionPolicy(options);
+        if (!policy.enabled) {
+            const held = await readOpenCodeInventory({ homeDir: options.homeDir, stateDir: paths.state_dir, metadataOnly: true, include: () => false, sinceMs: options.sinceMs });
+            summary.discovered = held.discovered;
+            summary.unique = held.discovered;
+            summary.withheld = held.withheld;
+            summary.coverage = held.failures.length || policy.reason === "owner_check_unavailable" ? "partial" : held.absent ? "absent" : "withheld";
+            summary.reasons.push(policy.reason, ...held.failures.map(failure => failure.reason));
+            if (summary.coverage === "partial")
+                await recordSourceRetryFailure(paths, { source: "opencode", attemptedAt: now.toISOString(), reason: held.failures[0]?.reason ?? policy.reason });
+            console.error("[opencode sync] source withheld", JSON.stringify(summary));
+            return summary;
+        }
+        const attributed = (directory) => scoreSignalsAgainstWorktrees({ cwds: [directory], workspaceRoots: [], originUrls: [], branches: [], headShas: [] }, options.worktrees, { collectionRoots: options.collectionRoots });
+        const cursor = await readRawEvidenceCursor(paths, { filename: OPENCODE_CURSOR_FILENAME, sessionsOnly: true });
+        const inventory = await readOpenCodeInventory({ homeDir: options.homeDir, stateDir: paths.state_dir, metadataOnly: options.dryRun, sinceMs: options.sinceMs, deliveredSessionIds: new Set(Object.entries(cursor.sessions).filter(([, entry]) => entry.uploaded_object_key).map(([id]) => id)), include: policy.include, countOnly: policy.drawer });
+        summary.discovered = inventory.discovered;
+        summary.withheld = inventory.withheld;
+        summary.eligible = inventory.eligible;
+        summary.pending = inventory.eligible - inventory.files.length;
+        summary.unique = inventory.discovered;
+        summary.reasons.push(...new Set(inventory.failures.map((failure) => failure.reason)));
+        if (inventory.absent)
+            summary.coverage = "absent";
+        if (options.dryRun) {
+            summary.pending = inventory.eligible;
+            if (inventory.failures.length)
+                summary.coverage = "partial";
+            return summary;
+        }
+        if (inventory.shelved.length) {
+            const [device, config] = await Promise.all([readLocalCollectorSessionFile(paths), readLocalCollectorConfig(paths)]);
+            const shelfReport = await reportShelvedSessions({ paths, dashboardUrl: options.dashboardUrl ?? config?.dashboard_url ?? null,
+                deviceToken: device?.device_token ?? null, fetchImpl: options.fetchImpl, allow: config?.shelf_metrics_allow ?? [], now,
+                shelved: inventory.shelved.map(file => ({ key: `opencode:${file.session.id}`, source: "opencode", reason: "drawer_shelf", facts: file.facts, recencyMs: file.session.updated_at_ms })) });
+            if (shelfReport.failed || shelfReport.not_counted)
+                summary.reasons.push("opencode_shelf_metrics_pending");
+        }
+        summary.new_since_last_scan = inventory.files.filter((file) => !cursor.sessions[file.session.id]).length;
+        summary.outside_roots = inventory.files.filter((file) => !cwdInsideRoots(file.session.directory, options.collectionRoots)).length;
+        const durableSessions = new Set();
+        const groups = new Map();
+        for (const file of inventory.files) {
+            const worktree = attributed(file.session.directory).worktree ?? outsideRootsWorkspace(options.homeDir);
+            const group = groups.get(worktree.worktree_fingerprint) ?? { worktree, files: [] };
+            group.files.push(file);
+            groups.set(worktree.worktree_fingerprint, group);
+        }
+        const budget = options.budget ?? { remainingBytes: RAW_EVIDENCE_DEFAULT_BYTE_BUDGET, remainingObjects: RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET };
+        for (const { worktree, files } of groups.values()) {
+            if (options.deadlineMs && Date.now() >= options.deadlineMs) {
+                summary.reasons.push("opencode_deadline_deferred");
+                summary.pending = summary.eligible - summary.delivered;
+                break;
+            }
+            if (isOutsideRootsWorkspace(worktree))
+                await fs.mkdir(worktree.repo_root, { recursive: true, mode: 0o700 });
+            const contextOptions = { homeDir: options.homeDir, repoRoot: worktree.repo_root, branch: worktree.branch, leaveActiveContext: true };
+            const context = isOutsideRootsWorkspace(worktree) ? await startLocalWorkContextForAttributedTarget(contextOptions, worktree) : await startLocalWorkContext(contextOptions);
+            const sync = await syncLocalAmbientEnvelope({ homeDir: options.homeDir, repoRoot: worktree.repo_root, dashboardUrl: options.dashboardUrl,
+                rawEvidenceBudget: budget, codexSessionFiles: [], claudeSessionFiles: [], nativeSessionFiles: files.map((file) => ({ local_path: file.local_path, session_id: file.session.id, source: "opencode", redaction: file.redaction })), fetch: options.fetchImpl });
+            if (sync.status !== "uploaded")
+                summary.reasons.push(sync.failure_reason);
+            const rows = files.map((file) => {
+                const attribution = attributed(file.session.directory);
+                const outcome = sync.raw_evidence_outcomes.find((item) => item.kind === "opencode_jsonl" && item.codex_session_id === file.session.id);
+                const pointer = outcome && (outcome.upload_state === "uploaded" || outcome.upload_state === "reused_existing") ? outcome.raw_evidence_pointer_id : null;
+                if (!pointer)
+                    summary.reasons.push(outcome?.reason ?? "opencode_delivery_pending");
+                return { source: "opencode", codex_session_id: file.session.id, observed_at: now.toISOString(), attribution_state: attribution.state,
+                    attribution_reason: attribution.reason, attribution_score: attribution.attribution_score, path_score: attribution.path_score, signals: attribution.signals,
+                    session_file_hash_sha256: file.revision, session_file_byte_size: file.byte_size, session_file_mtime: new Date(file.session.updated_at_ms).toISOString(), session_facts: file.facts,
+                    repo_fingerprint: attribution.worktree?.repo_fingerprint, worktree_fingerprint: attribution.worktree?.worktree_fingerprint,
+                    repo_label: attribution.worktree?.repo_label, branch: attribution.worktree?.branch, cwd_basename: path.basename(file.session.directory), cwd_hash: sha256(Buffer.from(file.session.directory)),
+                    root_scope: cwdInsideRoots(file.session.directory, options.collectionRoots) ? "inside" : "outside",
+                    raw_evidence_pointer_id: pointer ?? undefined, upload_state: pointer ? "uploaded" : "not_uploaded", upload_reason: pointer ? "durable_evidence_acknowledged" : outcome?.reason ?? "opencode_delivery_pending" };
+            });
+            // Durable metadata queue precedes cursor movement; an unavailable report endpoint cannot age sessions out.
+            await queueCodexSessionReport({ homeDir: options.homeDir, dashboardUrl: sync.dashboard_url, generatedAt: now.toISOString(), workContextId: context.work_context_id,
+                repoLabel: worktree.repo_label, branch: worktree.branch, repoFingerprint: worktree.repo_fingerprint, repoOriginUrl: worktree.repo_origin_url,
+                worktreeLabel: worktree.worktree_label, worktreeFingerprint: worktree.worktree_fingerprint, worktreeIsPrimary: worktree.worktree_is_primary, sessions: rows });
+            for (const [index, file] of files.entries()) {
+                const row = rows[index];
+                const pointer = row.raw_evidence_pointer_id ?? null;
+                if (pointer) {
+                    summary.delivered += 1;
+                    durableSessions.add(file.session.id);
+                }
+                else
+                    summary.pending += 1;
+                cursor.sessions[file.session.id] = { file_hash_sha256: file.revision, file_mtime_ms: file.session.updated_at_ms, byte_size: file.byte_size, byte_offset: pointer ? file.byte_size : 0,
+                    state: row.attribution_state, reason: row.attribution_reason, worktree_fingerprint: row.worktree_fingerprint ?? null, uploaded_object_key: pointer,
+                    uploaded_at: pointer ? now.toISOString() : null, uploaded_byte_size: pointer ? file.byte_size : null, last_seen_at: now.toISOString() };
+            }
+            cursor.updated_at = now.toISOString();
+            await writeRawEvidenceCursor(paths, cursor, { filename: OPENCODE_CURSOR_FILENAME, sessionsOnly: true });
+        }
+        const report = await flushPendingCodexSessionReports({ homeDir: options.homeDir, fetch: options.fetchImpl });
+        if (report.posted && report.failed_count === 0) {
+            await acknowledgeOpenCodeUsage(paths.state_dir, durableSessions);
+            // The shared pack/spool owns acknowledged bytes now; these are disposable redacted reader derivatives.
+            for (const file of inventory.files)
+                if (durableSessions.has(file.session.id))
+                    await fs.unlink(file.local_path).catch(() => undefined);
+        }
+        if (inventory.files.length && (!report.posted || report.failed_count > 0)) {
+            summary.reasons.push(report.reason);
+            summary.pending += summary.delivered;
+            summary.delivered = 0;
+        }
+        summary.reasons = [...new Set(summary.reasons)];
+        if (summary.pending || summary.reasons.length)
+            summary.coverage = "partial";
+        if (summary.coverage === "partial")
+            await recordSourceRetryFailure(paths, { source: "opencode", attemptedAt: now.toISOString(), reason: summary.reasons[0] ?? "opencode_delivery_pending" });
+        else
+            await clearSourceRetryFailure(paths, "opencode", now.toISOString());
+    }
+    catch (error) {
+        summary.pending = Math.max(summary.pending, summary.eligible - summary.delivered);
+        summary.coverage = "partial";
+        summary.reasons.push("opencode_sync_failed");
+        await recordSourceRetryFailure(paths, { source: "opencode", attemptedAt: now.toISOString(), reason: "opencode_sync_failed" });
+        console.error("[opencode sync] pass failed; native sessions remain retryable", JSON.stringify({ reason: "opencode_sync_failed", ...describeError(error) }));
+    }
+    finally {
+        if (!options.dryRun) {
+            try {
+                await writeJsonFileAtomic(path.join(paths.state_dir, "opencode-collection-status.json"), { observed_at: now.toISOString(), ...summary });
+            }
+            catch (error) {
+                summary.coverage = "partial";
+                summary.reasons.push("opencode_coverage_receipt_write_failed");
+                console.error("[opencode sync] coverage receipt not written", JSON.stringify({ reason: "opencode_coverage_receipt_write_failed", ...describeError(error) }));
+            }
+        }
+    }
+    console.error("[opencode sync] pass finished", JSON.stringify(summary));
+    return summary;
+}

package/dist/commands/public-root.js

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

package/dist/commands/session-sync-failures.js

@@ -170,4 +170,8 @@ export function recordUnexplainedFailure(ledger) {
         label: SYNC_FAILED_WITHOUT_REASON,
         rendered: SYNC_FAILED_WITHOUT_REASON,
     });
+}
+/** Keep native partial outcomes in the same closed failure ledger as legacy sources. */
+export function recordOpenCodeFailures(ledger, native) {
+    ledger.fail(native.coverage === "partial", "opencode_scan_read_failed", native.reasons[0] ?? "opencode_delivery_pending");
 }

package/dist/commands/session-sync-record.js

@@ -317,11 +317,13 @@ function recordSourceObservation(options, result) {
     const uploadedAt = uploadedThisSync
         ? options.now.toISOString()
         : (prior?.uploaded_at ?? (durableThisSync ? options.now.toISOString() : null));
-    const uploadedByteSize = uploadedThisSync
+    const uploadedByteSize = uploadedThisSync || (durableThisSync && options.source === "codex")
         ? result.byte_size
         : (prior?.uploaded_byte_size ?? (durableThisSync ? result.byte_size : null));
     const entry = {
         file_hash_sha256: result.content_hash_sha256,
+        uploaded_source_revision: durableThisSync && !("t3_projection_incomplete" in result && result.t3_projection_incomplete) && !isRedactionStubObjectKey(uploadedObjectKey)
+            ? result.content_hash_sha256 : prior?.uploaded_source_revision ?? null,
         file_mtime_ms: result.session_file_mtime_ms,
         byte_size: result.byte_size,
         // Durable byte offset reflects how many bytes are durable remotely (the

package/dist/commands/session-sync-scan.js

@@ -1,3 +1,4 @@
+import { nativeSessionRoots } from "../native-session-roots.js";
 /**
  * Reading both session stores, and settling what the reading owes.
  *
@@ -9,7 +10,7 @@
  */
 import path from "node:path";
 import { saveRootWorkScan } from "../root-work.js";
-import { CODEX_ATTRIBUTION_SCAN_WINDOW_SESSION_LIMIT, CODEX_ATTRIBUTION_SCAN_WINDOW_MINUTES, defaultCodexSessionDirs, scanAndAttributeCodexSessions, } from "../adapters/codex-attribution.js";
+import { CODEX_ATTRIBUTION_SCAN_WINDOW_SESSION_LIMIT, CODEX_ATTRIBUTION_SCAN_WINDOW_MINUTES, scanAndAttributeCodexSessions, } from "../adapters/codex-attribution.js";
 import { scanAndAttributeClaudeSessions, } from "../adapters/claude-attribution.js";
 import { CLAUDE_CURSOR_FILENAME } from "../cursors/raw-evidence-cursor.js";
 import { isRedactionStubObjectKey } from "../cursors/raw-evidence-stub-entry.js";
@@ -31,9 +32,10 @@ const CLAUDE_DEFAULT_WINDOW_MINUTES = 24 * 60;
  */
 export async function scanAndAttributeBothSources(options) {
     const { plan } = options;
+    const roots = nativeSessionRoots(options.homeDir);
     const codexScanned = await scanCodexSessionsForSync({
         codexEnabled: plan.codexEnabled,
-        homeDir: options.homeDir,
+        roots,
         worktrees: options.worktrees,
         now: options.now,
         collectionRoots: plan.collectionRoots,
@@ -48,7 +50,7 @@ export async function scanAndAttributeBothSources(options) {
     const firstRunBackfill = plan.claudeEnabled && !claudeCursorExists;
     const claudeScanned = await scanClaudeSessionsForSync({
         claudeEnabled: plan.claudeEnabled,
-        homeDir: options.homeDir,
+        roots,
         worktrees: options.worktrees,
         now: options.now,
         collectionRoots: plan.collectionRoots,
@@ -58,6 +60,10 @@ export async function scanAndAttributeBothSources(options) {
         outsideRootCatchUpPending: plan.outsideRootCatchUpPending,
         stateDir: options.paths.state_dir,
     });
+    if (roots.discoveryFailed) {
+        codexScanned.directory_read_failed_count += 1;
+        claudeScanned.project_dir_read_failed_count += 1;
+    }
     // BLI-23590: under `roots_only` a session outside every approved root leaves the result HERE, before the retry
     // bookkeeping, the local work scan, the upload, the report or the git scan can see it.
     let codexAttribution = codexScanned;
@@ -117,7 +123,7 @@ async function scanCodexSessionsForSync(options) {
     const readMemo = await openTranscriptReadMemo(options.stateDir, "codex_attribution").catch(() => undefined);
     try {
         let scan = await scanAndAttributeCodexSessions({
-            sessionsDirs: defaultCodexSessionDirs(options.homeDir),
+            sessionsDirs: options.roots.codex,
             worktrees: options.worktrees,
             now: options.now,
             sinceMinutes,
@@ -130,7 +136,7 @@ async function scanCodexSessionsForSync(options) {
             // capped scan still returns every session it found instead of silently
             // truncating at the window's default limit.
             scan = await scanAndAttributeCodexSessions({
-                sessionsDirs: defaultCodexSessionDirs(options.homeDir),
+                sessionsDirs: options.roots.codex,
                 worktrees: options.worktrees,
                 now: options.now,
                 sinceMinutes,
@@ -159,12 +165,13 @@ async function scanClaudeSessionsForSync(options) {
         : options.firstRunBackfill
             ? CLAUDE_FIRST_RUN_BACKFILL_MINUTES
             : undefined, options.outsideRootCatchUpPending, CLAUDE_DEFAULT_WINDOW_MINUTES);
-    const projectsDir = path.join(options.homeDir, ".claude", "projects");
+    const { claudeProjects: projectsDir, claudeProjectDirs: projectsDirs } = options.roots;
     // BLI-22797: one memo for both passes, settled once, so an unchanged file is never opened.
     const readMemo = await openTranscriptReadMemo(options.stateDir, "attribution").catch(() => undefined);
     try {
         let scan = await scanAndAttributeClaudeSessions({
             projectsDir,
+            projectsDirs,
             worktrees: options.worktrees,
             now: options.now,
             collectionRoots: options.collectionRoots,
@@ -174,6 +181,7 @@ async function scanClaudeSessionsForSync(options) {
         if (scan.session_limit_applied) {
             scan = await scanAndAttributeClaudeSessions({
                 projectsDir,
+                projectsDirs,
                 worktrees: options.worktrees,
                 now: options.now,
                 collectionRoots: options.collectionRoots,

package/dist/commands/session-sync-shelf.js

@@ -34,6 +34,8 @@ export function sessionShelf(result, rules) {
         return { shelf: "team", reason: "routing_inactive" };
     if (rules.failed)
         return { shelf: "drawer", reason: "shelf_resolve_failed" };
+    if (result.local_cwds && (result.local_cwds.length === 0 || result.local_cwds.some(cwd => !cwd || resolveShelfWith(rules, cwd).shelf !== "team")))
+        return { shelf: "drawer", reason: "shelf_identity_mismatch" };
     if (result.state === "ambiguous")
         return { shelf: "drawer", reason: "ambiguous_attribution" };
     const byWorktree = result.worktree && !isOutsideRootsWorkspace(result.worktree)

package/dist/commands/session-sync-upload.js

@@ -39,7 +39,7 @@ export async function syncEveryTargetWorktree(options) {
     // sessionId -> prior durable pointer for damped sessions (drives the
     // growth_damped count + the skip_main decision).
     const dampedClaudePointers = new Map();
-    const rawEvidenceBudget = {
+    const rawEvidenceBudget = run.rawEvidenceBudget ?? {
         remainingBytes: RAW_EVIDENCE_DEFAULT_BYTE_BUDGET,
         remainingObjects: RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET,
     };
@@ -180,6 +180,8 @@ function ambientEnvelopeForWorktree(options) {
             .map((result) => ({
             local_path: result.file_path,
             codex_session_id: result.codex_session_id,
+            ...(result.t3_projection ? { t3_projection: true } : {}),
+            ...(result.segment_paths ? { segment_paths: result.segment_paths, revision_hash: result.content_hash_sha256 ?? undefined, revision_bytes: result.byte_size } : {}),
         })),
         codexAttributionScan: scan.codexAttribution,
         claudeSessionFiles,

package/dist/commands/session-sync.js

@@ -1,3 +1,4 @@
+import { createSyncFailureLedger, recordOpenCodeFailures } from "./session-sync-failures.js";
 import { readLocalWorkContextForRepo } from "../local-state.js";
 /**
  * One attributed sync pass: scan both session stores, attribute what they hold,
@@ -39,6 +40,8 @@ import { readLocalWorkContextForRepo } from "../local-state.js";
  * `runtimeFiles`, or the repo tests stay green while the packed CLI breaks.
  */
 import os from "node:os";
+import { RAW_EVIDENCE_DEFAULT_BYTE_BUDGET, RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET } from "../adapters/raw-evidence.js";
+import { syncOpenCodeSessions } from "./opencode-sync.js";
 import { getCollectorRuntimePaths, readLocalCollectorConfig, readLocalCollectorSessionFile } from "../local-state.js";
 import { reportShelvedSessions } from "../shelf-reports.js";
 import { splitScanByShelf } from "./session-sync-shelf.js";
@@ -106,7 +109,7 @@ export async function runAttributedWorktreeSync(requested) {
         return heldSyncRun(scannedAll);
     const shelfSplit = splitScanByShelf({ scan: scannedAll, worktrees: requested.worktrees, decision: shelfDecision });
     const scanned = shelfSplit.scan;
-    const options = { ...requested, worktrees: shelfSplit.worktrees };
+    const options = { ...requested, worktrees: shelfSplit.worktrees, rawEvidenceBudget: requested.rawEvidenceBudget ?? { remainingBytes: RAW_EVIDENCE_DEFAULT_BYTE_BUDGET, remainingObjects: RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET } };
     // BLI-17916: roots are a label, never a gate. Outside-root sessions ride this
     // tick's upload under the synthetic workspace, a few per tick, newest first.
     const scan = await admitOutsideRootSessions({
@@ -141,8 +144,22 @@ export async function runAttributedWorktreeSync(requested) {
     reportCountedSessionFacts(sessions);
     const shelfReports = await sendShelfReports(options, paths, shelfSplit, now);
     const run = await finishAttributedSync(options, { paths, now, plan, scan, sessions, worktreePass });
+    const opencode = await syncOpenCodeSessions({ homeDir, worktrees: requested.worktrees, collectionRoots: plan.collectionRoots, dashboardUrl: requested.dashboardUrl, fetchImpl: requested.fetchImpl, budget: options.rawEvidenceBudget });
+    const failures = createSyncFailureLedger();
+    for (const failure of run.failure_records)
+        failures.add(failure);
+    recordOpenCodeFailures(failures, opencode);
     return {
         ...run,
+        opencode,
+        summary: { ...run.summary, opencode },
+        sessions_new_this_tick: run.sessions_new_this_tick + opencode.new_since_last_scan,
+        sessions_outside_root: run.sessions_outside_root + opencode.outside_roots,
+        ok: run.ok && opencode.coverage !== "partial",
+        failure_reasons: [...run.failure_reasons, ...(opencode.coverage === "partial" ? opencode.reasons.length ? opencode.reasons : ["opencode_delivery_pending"] : [])],
+        failure_records: failures.sortedRecords(),
+        sessions_observed: run.sessions_observed + opencode.eligible,
+        sessions_pending_upload: run.sessions_pending_upload + opencode.pending,
         sessions_shelved: shelfSplit.shelved.length,
         packs_refused: worktreePass.packsRefused ?? 0,
         shelf_reports: shelfReports,