slack-term 1.35.0 → 1.37.0

package/ts/leveldb.ts

@@ -0,0 +1,154 @@
+// Minimal read-only LevelDB SSTable (.ldb) reader + Snappy decompressor.
+//
+// Chrome/Electron store LocalStorage in LevelDB, and its .ldb (sorted table)
+// files keep data blocks Snappy-compressed, so a raw regex scan can't recover a
+// value that a Snappy copy-op split apart. This module decompresses the data
+// blocks and returns their concatenated bytes for scanning — it recovers record
+// VALUES only (enough to find "token":"xoxc-…"); it is not a general client and
+// does no key lookup, bloom/filter handling, or CRC verification.
+//
+// SSTable layout (github.com/google/leveldb/blob/main/doc/table_format.md):
+//   file = block* + metaindex_block + index_block + footer
+//   block = content-bytes + type(1) + crc32c(4)   (type 0 = raw, 1 = snappy)
+//   footer (last 48 bytes) = metaindex_handle + index_handle + pad + magic(8)
+//   BlockHandle = varint(offset) + varint(size)   (size excludes the 5-byte trailer)
+
+const FOOTER_LEN = 48;
+
+/** Read a LEB128 varint using float arithmetic so 64-bit offsets/sizes stay exact past 2^31. */
+function readVarint(buf: Buffer, pos: number): { value: number; pos: number } {
+  let value = 0;
+  let shift = 0;
+  let p = pos;
+  while (p < buf.length) {
+    const b = buf[p++]!;
+    value += (b & 0x7f) * 2 ** shift;
+    if ((b & 0x80) === 0) break;
+    shift += 7;
+  }
+  return { value, pos: p };
+}
+
+/** Decompress a Snappy block (raw format: varint uncompressed-length preamble, then tags). */
+export function snappyUncompress(input: Buffer): Buffer {
+  // Preamble: total uncompressed length.
+  let pos = 0;
+  let outLen = 0;
+  let shift = 0;
+  while (pos < input.length) {
+    const b = input[pos++]!;
+    outLen += (b & 0x7f) * 2 ** shift;
+    if ((b & 0x80) === 0) break;
+    shift += 7;
+  }
+
+  const out = Buffer.allocUnsafe(outLen);
+  let op = 0;
+  while (pos < input.length && op < outLen) {
+    const tag = input[pos++]!;
+    const type = tag & 0x3;
+    if (type === 0) {
+      // Literal: length-1 in the upper 6 bits, or in the following 1-4 bytes when >= 60.
+      let len = tag >> 2;
+      if (len >= 60) {
+        const extra = len - 59;
+        len = 0;
+        for (let i = 0; i < extra; i++) len += input[pos++]! * 2 ** (8 * i);
+      }
+      len += 1;
+      input.copy(out, op, pos, pos + len);
+      pos += len;
+      op += len;
+    } else {
+      // Copy: length + back-reference offset into the already-produced output.
+      let length: number;
+      let offset: number;
+      if (type === 1) {
+        length = 4 + ((tag >> 2) & 0x7);
+        offset = ((tag >> 5) & 0x7) * 256 + input[pos++]!;
+      } else if (type === 2) {
+        length = 1 + (tag >> 2);
+        offset = input[pos]! + input[pos + 1]! * 256;
+        pos += 2;
+      } else {
+        length = 1 + (tag >> 2);
+        offset = input[pos]! + input[pos + 1]! * 256 + input[pos + 2]! * 65536 + input[pos + 3]! * 16777216;
+        pos += 4;
+      }
+      let src = op - offset;
+      for (let i = 0; i < length && op < outLen; i++) out[op++] = out[src++]!;
+    }
+  }
+  return op === outLen ? out : out.subarray(0, op);
+}
+
+type BlockHandle = { offset: number; size: number };
+
+function decodeBlockHandle(buf: Buffer, pos: number): { handle: BlockHandle; pos: number } {
+  const off = readVarint(buf, pos);
+  const sz = readVarint(buf, off.pos);
+  return { handle: { offset: off.value, size: sz.value }, pos: sz.pos };
+}
+
+/** Read one block's content, decompressing when the trailer marks it Snappy (type 1). */
+function readBlockContent(file: Buffer, handle: BlockHandle): Buffer {
+  const { offset, size } = handle;
+  const raw = file.subarray(offset, offset + size);
+  const type = file[offset + size];
+  return type === 1 ? snappyUncompress(raw) : Buffer.from(raw);
+}
+
+/** Iterate a decompressed block's entries, yielding each value's bytes (keys reconstructed but unused here). */
+function blockValues(block: Buffer): Buffer[] {
+  if (block.length < 4) return [];
+  const numRestarts = block.readUInt32LE(block.length - 4);
+  const entriesEnd = block.length - (numRestarts + 1) * 4;
+  const values: Buffer[] = [];
+  let pos = 0;
+  let prevKey = Buffer.alloc(0);
+  while (pos < entriesEnd) {
+    const s = readVarint(block, pos);
+    const ns = readVarint(block, s.pos);
+    const vl = readVarint(block, ns.pos);
+    pos = vl.pos;
+    const shared = s.value;
+    const nonShared = ns.value;
+    const valueLen = vl.value;
+    const keyDelta = block.subarray(pos, pos + nonShared);
+    pos += nonShared;
+    const value = block.subarray(pos, pos + valueLen);
+    pos += valueLen;
+    prevKey = Buffer.concat([prevKey.subarray(0, shared), keyDelta]);
+    values.push(value);
+  }
+  return values;
+}
+
+/**
+ * Decompress every data block referenced by an SSTable's index and return their
+ * concatenated bytes. Record values survive intact (Slack stores a workspace's
+ * config as one JSON string value), so the result can be regex-scanned.
+ * Returns an empty buffer if the file isn't a parseable SSTable.
+ */
+export function ldbDecompressedBytes(file: Buffer): Buffer {
+  if (file.length < FOOTER_LEN) return Buffer.alloc(0);
+  try {
+    const footerStart = file.length - FOOTER_LEN;
+    const meta = decodeBlockHandle(file, footerStart);   // metaindex handle (skipped)
+    const index = decodeBlockHandle(file, meta.pos);     // index handle
+    const indexBlock = readBlockContent(file, index.handle);
+    const chunks: Buffer[] = [];
+    for (const handleBytes of blockValues(indexBlock)) {
+      // Each index entry's value is a BlockHandle pointing at a data block.
+      try {
+        const { handle } = decodeBlockHandle(handleBytes, 0);
+        chunks.push(readBlockContent(file, handle));
+      } catch {
+        // skip a malformed handle
+      }
+    }
+    return Buffer.concat(chunks);
+  } catch {
+    return Buffer.alloc(0);
+  }
+}

package/ts/profiles.ts

@@ -20,7 +20,7 @@
 // Note: lockfiles and profiles.json use .slack-cli/ (older name); new per-dir token storage
 // uses .slack-term/ (current project name). Both coexist intentionally.
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, dirname } from "node:path";
 
@@ -30,11 +30,19 @@ export type Profile = {
   teamId: string;
   url: string;
   user: string;
-  cookie?: string; // xoxd session cookie for internal APIs (drafts, etc.)
+  cookie?: string;   // xoxd session cookie for internal APIs (drafts, etc.)
+  identity?: string; // owning user identity (e.g. account email) — groups workspaces and shares one cookie
+};
+
+/** Per-identity auth shared across all that identity's workspaces. */
+export type UserAuth = {
+  cookie?: string; // xoxd session cookie (workspace-agnostic — one per browser/user)
+  source?: string; // where it came from, e.g. "chrome:Profile 3"
 };
 
 type ProfileStore = {
   profiles: Record<string, Profile>;
+  users?: Record<string, UserAuth>; // identity -> shared auth; cookie stored here once
 };
 
 function home(): string {
@@ -62,7 +70,9 @@ function load(): ProfileStore {
 function save(store: ProfileStore): void {
   const path = profilesPath();
   mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, JSON.stringify(store, null, 2) + "\n");
+  if (process.platform !== "win32" && existsSync(path)) chmodSync(path, 0o600);
+  writeFileSync(path, JSON.stringify(store, null, 2) + "\n", { mode: 0o600 });
+  if (process.platform !== "win32") chmodSync(path, 0o600);
 }
 
 function readLockfile(path: string): string | undefined {
@@ -150,7 +160,9 @@ export function saveToEnvFile(filePath: string, updates: Record<string, string>)
       lines.push(newLine);
     }
   }
-  writeFileSync(filePath, lines.join("\n").trimEnd() + "\n");
+  if (process.platform !== "win32" && existsSync(filePath)) chmodSync(filePath, 0o600);
+  writeFileSync(filePath, lines.join("\n").trimEnd() + "\n", { mode: 0o600 });
+  if (process.platform !== "win32") chmodSync(filePath, 0o600);
 }
 
 export function listProfiles(): { name: string; profile: Profile; current: boolean }[] {
@@ -158,26 +170,66 @@ export function listProfiles(): { name: string; profile: Profile; current: boole
   const local = readLockfile(localLockfilePath());
   const global_ = readLockfile(globalLockfilePath());
   const current = local ?? global_;
-  return Object.entries(store.profiles).map(([name, profile]) => ({
-    name,
-    profile,
-    current: name === current,
-  }));
+  return Object.entries(store.profiles).map(([name, profile]) => {
+    // Surface the effective cookie (own, else the identity's shared one) so
+    // callers reading profile.cookie keep working after cookie hoisting.
+    const cookie = cookieFor(store, name);
+    return {
+      name,
+      profile: { ...profile, ...(cookie ? { cookie } : {}) },
+      current: name === current,
+    };
+  });
 }
 
 export function addProfile(name: string, profile: Profile): void {
   const store = load();
-  store.profiles[name] = profile;
+  // When the profile belongs to an identity, store its cookie once at the
+  // identity level (workspace-agnostic) rather than duplicating it per workspace.
+  if (profile.identity && profile.cookie) {
+    store.users ??= {};
+    const prev = store.users[profile.identity] ?? {};
+    store.users[profile.identity] = { ...prev, cookie: profile.cookie };
+    const { cookie: _drop, ...rest } = profile;
+    store.profiles[name] = rest;
+  } else {
+    store.profiles[name] = profile;
+  }
   save(store);
 }
 
 export function setCookie(name: string, cookie: string): void {
   const store = load();
-  if (!(name in store.profiles)) throw new Error(`Profile not found: ${name}`);
-  store.profiles[name]!.cookie = cookie;
+  const profile = store.profiles[name];
+  if (!profile) throw new Error(`Profile not found: ${name}`);
+  // Route through the identity's shared cookie when the workspace has one.
+  if (profile.identity) {
+    store.users ??= {};
+    store.users[profile.identity] = { ...(store.users[profile.identity] ?? {}), cookie };
+  } else {
+    profile.cookie = cookie;
+  }
   save(store);
 }
 
+/** Store (or refresh) the shared xoxd cookie for an identity — every workspace under it picks it up. */
+export function setUserCookie(identity: string, cookie: string, source?: string): void {
+  const store = load();
+  store.users ??= {};
+  store.users[identity] = { ...(store.users[identity] ?? {}), cookie, ...(source ? { source } : {}) };
+  save(store);
+}
+
+/** Resolve the effective xoxd cookie for a workspace: its own, else its identity's shared one. */
+function cookieFor(store: ProfileStore, name: string | undefined): string | undefined {
+  if (!name) return undefined;
+  const profile = store.profiles[name];
+  if (!profile) return undefined;
+  if (profile.cookie) return profile.cookie;
+  if (profile.identity) return store.users?.[profile.identity]?.cookie;
+  return undefined;
+}
+
 export function removeProfile(name: string): void {
   const store = load();
   if (!(name in store.profiles)) throw new Error(`Profile not found: ${name}`);
@@ -270,9 +322,11 @@ export function resolveToken(workspaceFlag?: string): string {
   throw new Error(
     "No Slack token found.\n" +
     "  Run one of:\n" +
-    "    slack auth login    — paste an existing xoxp-/xoxb- token\n" +
-    "    slack auth chrome   — import from Chrome browser (macOS)\n" +
-    "    slack auth app      — guided Slack app creation\n" +
+    "    slack auth login          — interactive wizard (desktop / browser / token / new app)\n" +
+    "    slack auth login chrome   — import workspaces from Chrome (all platforms)\n" +
+    "    slack auth cookie         — attach the xoxd cookie from Chrome (macOS/Windows)\n" +
+    "    slack auth firefox        — attach the xoxd cookie from Firefox (all platforms)\n" +
+    "    slack auth token --token xoxp-...   — paste an existing token\n" +
     "  Or set SLACK_TOKEN=xoxp-... in .slack-term/.env.local",
   );
 }
@@ -294,7 +348,7 @@ export function resolveCookie(workspaceFlag?: string): string | undefined {
   const profiles = store.profiles;
 
   // --workspace flag: skip env-file walk, go straight to profiles.json
-  if (workspaceFlag) return profiles[workspaceFlag]?.cookie;
+  if (workspaceFlag) return cookieFor(store, workspaceFlag);
 
   // process.env: SLACK_COOKIE (official extension), legacy SLACK_MCP_XOXD_COOKIE
   if (process.env.SLACK_COOKIE) return process.env.SLACK_COOKIE;
@@ -312,13 +366,13 @@ export function resolveCookie(workspaceFlag?: string): string | undefined {
 
   // profiles.json via SLACK_WORKSPACE env var or lockfiles
   const selected = process.env.SLACK_WORKSPACE;
-  if (selected) return profiles[selected]?.cookie;
+  if (selected) return cookieFor(store, selected);
 
   const localName = readLockfile(localLockfilePath());
-  if (localName) return profiles[localName]?.cookie;
+  if (localName) return cookieFor(store, localName);
 
   const globalName = readLockfile(globalLockfilePath());
-  if (globalName) return profiles[globalName]?.cookie;
+  if (globalName) return cookieFor(store, globalName);
 
   return undefined;
 }

package/ts/sentlog.ts

@@ -0,0 +1,356 @@
+// Local record of every message this CLI posted or edited, and WHO posted it.
+//
+// Why this exists: an agent asked a question, the human answered it, and no one
+// collected the answer. Finding which agent had asked took a grep over ~1.8 GB
+// of session transcripts, then matching cwd and start time to a live pid
+// (measured 2026-09-27). The sender is known for certain at the moment of
+// sending — this file writes it down then, instead of reconstructing it later.
+//
+// Two places, on purpose:
+//   - a local SQLite log (~/.config/slack-cli/sent.sqlite), which `slack sent`
+//     and `slack ask --pending` read;
+//   - Slack message `metadata` (event_type `slack_term_sent`), invisible to
+//     readers but returned by the API, so a machine WITHOUT the log can still
+//     attribute a message.
+//
+// Everything here is fail-soft. A message that was posted must never be
+// reported as failed because the bookkeeping about it failed.
+//
+// Opt out with SLACK_TERM_ATTRIBUTION=off (no log, no metadata).
+
+import { spawnSync } from "node:child_process";
+import { chmodSync, mkdirSync } from "node:fs";
+import { homedir, hostname } from "node:os";
+import { basename, dirname, join } from "node:path";
+
+export type SentKind = "send" | "ask" | "edit" | "poll";
+
+/** Who sent it. Every field is best-effort; a missing one is left undefined
+ *  rather than guessed. */
+export interface Attribution {
+  /** The `slack` process itself — short-lived, kept for completeness. */
+  pid: number;
+  /** The long-lived agent process that ran `slack` — what "is the sender still
+   *  alive?" has to check. */
+  agentPid?: number;
+  host: string;
+  cwd: string;
+  gitBranch?: string;
+  /** claude-code, codex, … — see detectCli. */
+  cli?: string;
+  sessionId?: string;
+}
+
+export interface SentRow {
+  id: number;
+  kind: SentKind;
+  team?: string | null;
+  channel: string;
+  target?: string | null;
+  ts: string;
+  thread_ts?: string | null;
+  permalink?: string | null;
+  text: string;
+  sent_at: number;
+  pid: number;
+  agent_pid?: number | null;
+  host?: string | null;
+  cwd: string;
+  git_branch?: string | null;
+  cli?: string | null;
+  session_id?: string | null;
+  as_bot: number;
+  collected_at?: number | null;
+  answer?: string | null;
+  answer_exit?: number | null;
+  delivered_at?: number | null;
+}
+
+export function attributionEnabled(): boolean {
+  return !/^(0|off|false|no)$/i.test(process.env.SLACK_TERM_ATTRIBUTION ?? "");
+}
+
+// --- attribution -------------------------------------------------------------
+
+/** Agent CLIs recognised by process name when no env var names them. */
+const AGENT_PROCESS_NAMES: Record<string, string> = {
+  claude: "claude-code",
+  codex: "codex",
+  gemini: "gemini",
+  opencode: "opencode",
+  "cursor-agent": "cursor-agent",
+  aider: "aider",
+  amp: "amp",
+};
+
+type Proc = { pid: number; ppid: number; comm: string };
+
+function procInfo(pid: number): Proc | undefined {
+  try {
+    const r = spawnSync("ps", ["-o", "ppid=,comm=", "-p", String(pid)], { encoding: "utf8", timeout: 2000 });
+    const m = (r.stdout ?? "").trim().match(/^(\d+)\s+(.+)$/);
+    if (!m) return undefined;
+    return { pid, ppid: Number(m[1]), comm: basename(m[2]!.trim()) };
+  } catch {
+    return undefined;
+  }
+}
+
+/** The nearest ancestor whose process name is a known agent CLI. */
+function findAgentAncestor(): Proc | undefined {
+  let pid = process.ppid;
+  for (let i = 0; i < 12 && pid > 1; i++) {
+    const p = procInfo(pid);
+    if (!p) return undefined;
+    if (AGENT_PROCESS_NAMES[p.comm]) return p;
+    pid = p.ppid;
+  }
+  return undefined;
+}
+
+function positiveInt(s: string | undefined): number | undefined {
+  const n = Number(s);
+  return Number.isInteger(n) && n > 0 ? n : undefined;
+}
+
+/** Read the sender off the environment and process tree.
+ *
+ *  Env vars used, and only those verified against a real session (2026-09-27):
+ *  Claude Code sets CLAUDE_CODE_SESSION_ID, CLAUDE_PID and AI_AGENT
+ *  (`claude-code_<version>_agent`). Other CLIs are recognised by the process
+ *  name of an ancestor; their session ids are not read because their variable
+ *  names were not verified. A wrapper that knows better sets the overrides:
+ *  SLACK_TERM_AGENT_CLI, SLACK_TERM_AGENT_SESSION, SLACK_TERM_AGENT_PID. */
+export function captureAttribution(env: NodeJS.ProcessEnv = process.env): Attribution {
+  const a: Attribution = { pid: process.pid, host: safeHostname(), cwd: process.cwd() };
+
+  let cli = env.SLACK_TERM_AGENT_CLI || undefined;
+  if (!cli && env.AI_AGENT) cli = env.AI_AGENT.split("_")[0] || undefined;
+  if (!cli && env.CLAUDECODE === "1") cli = "claude-code";
+
+  let agentPid = positiveInt(env.SLACK_TERM_AGENT_PID) ?? positiveInt(env.CLAUDE_PID);
+  if (!agentPid || !cli) {
+    const anc = findAgentAncestor();
+    if (anc) {
+      agentPid ??= anc.pid;
+      cli ??= AGENT_PROCESS_NAMES[anc.comm];
+    }
+  }
+  if (cli) a.cli = cli;
+  if (agentPid) a.agentPid = agentPid;
+
+  const session = env.SLACK_TERM_AGENT_SESSION || env.CLAUDE_CODE_SESSION_ID;
+  if (session) a.sessionId = session;
+
+  const branch = gitBranch(a.cwd);
+  if (branch) a.gitBranch = branch;
+  return a;
+}
+
+function safeHostname(): string {
+  try {
+    return hostname();
+  } catch {
+    return "";
+  }
+}
+
+function gitBranch(cwd: string): string | undefined {
+  try {
+    const r = spawnSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd, encoding: "utf8", timeout: 2000 });
+    const b = r.status === 0 ? (r.stdout ?? "").trim() : "";
+    return b || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Slack message metadata: invisible in the client, returned by the API
+ *  (`include_all_metadata`). Only defined fields — Slack rejects nulls. */
+export const METADATA_EVENT_TYPE = "slack_term_sent";
+
+export function attributionMetadata(kind: SentKind, a: Attribution): { event_type: string; event_payload: Record<string, string | number> } {
+  const p: Record<string, string | number> = { kind, pid: a.pid, host: a.host, cwd: a.cwd };
+  if (a.agentPid) p.agent_pid = a.agentPid;
+  if (a.gitBranch) p.git_branch = a.gitBranch;
+  if (a.cli) p.cli = a.cli;
+  if (a.sessionId) p.session_id = a.sessionId;
+  return { event_type: METADATA_EVENT_TYPE, event_payload: p };
+}
+
+// --- the database ------------------------------------------------------------
+
+/** The subset of bun:sqlite / node:sqlite both provide. */
+interface Stmt { run(...p: unknown[]): unknown; all(...p: unknown[]): unknown[]; }
+interface Db { exec(sql: string): void; prepare(sql: string): Stmt; close(): void; }
+
+export function sentDbPath(): string {
+  if (process.env.SLACK_TERM_SENT_DB) return process.env.SLACK_TERM_SENT_DB;
+  return join(process.env.HOME || homedir(), ".config", "slack-cli", "sent.sqlite");
+}
+
+function openSqlite(path: string): Db | undefined {
+  // bun:sqlite under bun (how the tests and `bun run` execute), node:sqlite
+  // under node 22.5+ (the published dist build). Neither → no log, said once.
+  try {
+    if (typeof (globalThis as { Bun?: unknown }).Bun !== "undefined") {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const { Database } = require("bun:sqlite") as typeof import("bun:sqlite");
+      return new Database(path, { create: true }) as unknown as Db;
+    }
+    const mod = (process as unknown as { getBuiltinModule?: (id: string) => unknown }).getBuiltinModule?.("node:sqlite") as
+      | { DatabaseSync: new (p: string) => Db }
+      | undefined;
+    if (mod?.DatabaseSync) return new mod.DatabaseSync(path);
+  } catch {
+    // fall through
+  }
+  return undefined;
+}
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS sent (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  kind TEXT NOT NULL,
+  team TEXT,
+  channel TEXT NOT NULL,
+  target TEXT,
+  ts TEXT NOT NULL,
+  thread_ts TEXT,
+  permalink TEXT,
+  text TEXT NOT NULL,
+  sent_at INTEGER NOT NULL,
+  pid INTEGER NOT NULL,
+  agent_pid INTEGER,
+  host TEXT,
+  cwd TEXT NOT NULL,
+  git_branch TEXT,
+  cli TEXT,
+  session_id TEXT,
+  as_bot INTEGER NOT NULL DEFAULT 0,
+  collected_at INTEGER,
+  answer TEXT,
+  answer_exit INTEGER,
+  delivered_at INTEGER
+);
+CREATE INDEX IF NOT EXISTS sent_msg ON sent(channel, ts);
+CREATE INDEX IF NOT EXISTS sent_at ON sent(sent_at);
+`;
+
+export function openSentLog(): Db | undefined {
+  const path = sentDbPath();
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+  } catch {
+    // openSqlite reports it
+  }
+  const db = openSqlite(path);
+  if (!db) return undefined;
+  // Owner-only: the log holds full outgoing text, DMs and private channels
+  // included, plus session ids. Applied on every open so a log created before
+  // this (or under a loose umask) is tightened too.
+  try { chmodSync(path, 0o600); } catch { /* best-effort */ }
+  try {
+    db.exec(SCHEMA);
+    return db;
+  } catch {
+    try { db.close(); } catch { /* ignore */ }
+    return undefined;
+  }
+}
+
+export interface RecordSent {
+  kind: SentKind;
+  team?: string | undefined;
+  channel: string;
+  target?: string | undefined;
+  ts: string;
+  threadTs?: string | undefined;
+  permalink?: string | undefined;
+  text: string;
+  asBot?: boolean | undefined;
+  attribution: Attribution;
+}
+
+/** Append one row. Never throws — returns false and warns on stderr instead. */
+export function recordSent(r: RecordSent): boolean {
+  if (!attributionEnabled()) return false;
+  const db = openSentLog();
+  if (!db) {
+    console.error(`  (送信ログに記録できませんでした: ${SENT_LOG_UNAVAILABLE} — ${sentDbPath()})`);
+    return false;
+  }
+  try {
+    const a = r.attribution;
+    db.prepare(
+      `INSERT INTO sent (kind, team, channel, target, ts, thread_ts, permalink, text, sent_at, pid, agent_pid, host, cwd, git_branch, cli, session_id, as_bot)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    ).run(
+      r.kind, r.team ?? null, r.channel, r.target ?? null, r.ts, r.threadTs ?? null, r.permalink ?? null, r.text,
+      Date.now(), a.pid, a.agentPid ?? null, a.host || null, a.cwd, a.gitBranch ?? null, a.cli ?? null, a.sessionId ?? null,
+      r.asBot ? 1 : 0,
+    );
+    return true;
+  } catch (e: unknown) {
+    console.error(`  (送信ログに記録できませんでした: ${e instanceof Error ? e.message : String(e)})`);
+    return false;
+  } finally {
+    try { db.close(); } catch { /* ignore */ }
+  }
+}
+
+// --- querying ----------------------------------------------------------------
+
+export interface SentQuery {
+  text?: string;
+  channel?: string;
+  sinceMs?: number;
+  session?: string;
+  cwd?: string;
+  kind?: SentKind;
+  limit?: number;
+}
+
+/** Newest first. `channel` matches the id or the target as typed (`#eng`, `@bob`);
+ *  `session` and `cwd` are prefix matches; `text` is a case-insensitive substring. */
+/** Why the log cannot be opened in this runtime — the storage is SQLite, which
+ *  needs bun or node ≥ 22.5 (`node:sqlite`). Surfaced by `slack sent`, which
+ *  must not answer "no matches" when the truth is "no log". */
+export const SENT_LOG_UNAVAILABLE =
+  "送信ログを開けません: SQLite が使えないランタイムです (bun、または node >= 22.5 の node:sqlite が必要)";
+
+/** Newest first, or `undefined` when the log cannot be opened at all. */
+export function querySent(q: SentQuery): SentRow[] | undefined {
+  const db = openSentLog();
+  if (!db) return undefined;
+  try {
+    const where: string[] = [];
+    const params: unknown[] = [];
+    if (q.text) { where.push("text LIKE ? ESCAPE '\\'"); params.push(`%${likeEscape(q.text)}%`); }
+    if (q.channel) { where.push("(channel = ? OR target = ?)"); params.push(q.channel, q.channel); }
+    if (q.sinceMs !== undefined) { where.push("sent_at >= ?"); params.push(q.sinceMs); }
+    if (q.session) { where.push("session_id LIKE ? ESCAPE '\\'"); params.push(`${likeEscape(q.session)}%`); }
+    if (q.cwd) { where.push("cwd LIKE ? ESCAPE '\\'"); params.push(`${likeEscape(q.cwd)}%`); }
+    if (q.kind) { where.push("kind = ?"); params.push(q.kind); }
+    const sql = `SELECT * FROM sent${where.length ? ` WHERE ${where.join(" AND ")}` : ""} ORDER BY sent_at DESC, id DESC LIMIT ?`;
+    params.push(q.limit ?? 50);
+    return db.prepare(sql).all(...params) as SentRow[];
+  } finally {
+    try { db.close(); } catch { /* ignore */ }
+  }
+}
+
+function likeEscape(s: string): string {
+  return s.replace(/[\\%_]/g, (c) => `\\${c}`);
+}
+
+/** `30m`, `2h`, `7d`, `1w`, or an ISO date/time → epoch ms. Undefined if unreadable. */
+export function parseSince(s: string, now = Date.now()): number | undefined {
+  const m = s.trim().match(/^(\d+(?:\.\d+)?)\s*(s|m|h|d|w)$/i);
+  if (m) {
+    const unit = { s: 1e3, m: 60e3, h: 3600e3, d: 86400e3, w: 7 * 86400e3 }[m[2]!.toLowerCase() as "s"]!;
+    return now - Number(m[1]) * unit;
+  }
+  const t = Date.parse(s);
+  return Number.isNaN(t) ? undefined : t;
+}