@raidiant/notifai 10.1.0 → 10.1.2

package/src/project-enablement.test.ts

@@ -1,55 +0,0 @@
-import { execFileSync } from 'node:child_process'
-import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { describe, expect, it } from 'vitest'
-import {
-  disableProject,
-  enableProject,
-  projectBinding,
-  projectEnabled,
-} from './project-enablement.js'
-
-function git(cwd: string, ...args: string[]): void {
-  execFileSync('git', ['-C', cwd, ...args], { stdio: 'ignore' })
-}
-
-describe('Project enablement', () => {
-  it('is disabled by default and changes only through its User-owned marker', () => {
-    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-enablement-'))
-    const env = { XDG_CONFIG_HOME: path.join(root, 'config') }
-    const binding = projectBinding(root, env)
-    expect(binding).not.toBeNull()
-    expect(projectEnabled(binding)).toBe(false)
-
-    enableProject(binding!, new Date('2026-08-27T00:00:00.000Z'))
-    expect(projectEnabled(binding)).toBe(true)
-    disableProject(binding!)
-    expect(projectEnabled(binding)).toBe(false)
-  })
-
-  it('shares one decision across linked worktrees but not unrelated checkouts with the same name', () => {
-    const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-enablement-git-'))
-    const repo = path.join(root, 'same-name')
-    const linked = path.join(root, 'linked')
-    const unrelatedParent = path.join(root, 'other')
-    const unrelated = path.join(unrelatedParent, 'same-name')
-    mkdirSync(repo, { recursive: true })
-    mkdirSync(unrelated, { recursive: true })
-    for (const cwd of [repo, unrelated]) {
-      git(cwd, 'init')
-      git(cwd, 'config', 'user.email', 'test@example.invalid')
-      git(cwd, 'config', 'user.name', 'Test')
-      writeFileSync(path.join(cwd, 'file'), 'x')
-      git(cwd, 'add', 'file')
-      git(cwd, 'commit', '-m', 'fixture')
-    }
-    git(repo, 'worktree', 'add', linked, '-b', 'linked')
-    const env = { XDG_CONFIG_HOME: path.join(root, 'config') }
-    const mainBinding = projectBinding(repo, env)
-    const linkedBinding = projectBinding(linked, env)
-    const unrelatedBinding = projectBinding(unrelated, env)
-    expect(linkedBinding?.markerPath).toBe(mainBinding?.markerPath)
-    expect(unrelatedBinding?.markerPath).not.toBe(mainBinding?.markerPath)
-  })
-})

package/src/project-enablement.ts

@@ -1,99 +0,0 @@
-import { execFileSync } from 'node:child_process'
-import { createHash } from 'node:crypto'
-import { existsSync, readFileSync, realpathSync, unlinkSync } from 'node:fs'
-import path from 'node:path'
-import { atomicWriteFileSync } from './atomic-file.js'
-import { globalConfigDir } from './config.js'
-import { inferInvocationContext } from './invocation-context.js'
-
-interface ProjectEnablementMarker {
-  version: 1
-  project: string
-  enabled: true
-  updated_at: string
-}
-
-export interface ProjectBinding {
-  project: string
-  markerPath: string
-}
-
-function gitCommonDirectory(cwd: string): string | null {
-  try {
-    const raw = execFileSync('git', ['-C', cwd, 'rev-parse', '--git-common-dir'], {
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-      timeout: 2_000,
-      windowsHide: true,
-    }).trim()
-    if (raw === '') return null
-    const resolved = path.isAbsolute(raw) ? raw : path.resolve(cwd, raw)
-    try {
-      return realpathSync(resolved)
-    } catch {
-      return path.resolve(resolved)
-    }
-  } catch {
-    return null
-  }
-}
-
-/**
- * Resolve the User-owned enablement record for this exact local Project.
- *
- * The opaque key binds the semantic Project id to Git's shared common
- * directory. Linked worktrees therefore share one decision, while another
- * checkout cannot borrow it merely by committing the same Project id.
- */
-export function projectBinding(
-  cwd: string,
-  env: NodeJS.ProcessEnv = process.env,
-  explicitProject?: string | null,
-): ProjectBinding | null {
-  const project = explicitProject ?? inferInvocationContext(cwd).project
-  if (project === null) return null
-  const repository = gitCommonDirectory(cwd) ?? path.resolve(cwd)
-  const key = createHash('sha256')
-    .update('notifai-project-enablement-v1\0')
-    .update(repository)
-    .update('\0')
-    .update(project)
-    .digest('hex')
-  return {
-    project,
-    markerPath: path.join(globalConfigDir(env), 'project-enablement', `${key}.json`),
-  }
-}
-
-export function projectEnabled(binding: ProjectBinding | null): boolean {
-  if (binding === null || !existsSync(binding.markerPath)) return false
-  try {
-    const marker = JSON.parse(readFileSync(binding.markerPath, 'utf8')) as Partial<ProjectEnablementMarker>
-    return marker.version === 1 && marker.enabled === true && marker.project === binding.project
-  } catch {
-    return false
-  }
-}
-
-export function enableProject(binding: ProjectBinding, now: Date = new Date()): void {
-  const marker: ProjectEnablementMarker = {
-    version: 1,
-    project: binding.project,
-    enabled: true,
-    updated_at: now.toISOString(),
-  }
-  atomicWriteFileSync(binding.markerPath, `${JSON.stringify(marker, null, 2)}\n`, {
-    mode: 0o600,
-    preserveMode: false,
-    requireCurrentUserOwner: true,
-    directoryMode: 0o700,
-  })
-}
-
-export function disableProject(binding: ProjectBinding): void {
-  try {
-    unlinkSync(binding.markerPath)
-  } catch (err) {
-    if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err
-  }
-}

package/src/question-caps.test.ts

@@ -1,49 +0,0 @@
-import { mkdtempSync } from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { describe, expect, it } from 'vitest'
-import { MAX_LIVE_QUESTIONS, MAX_PENDING_QUESTIONS, registerQuestion } from './hooks.js'
-
-/**
- * `registerQuestion` decides how many questions one session may hold, and these
- * exercise it directly against a bare state directory — no harness, no server,
- * no clock. They live apart from `hooks.test.ts` because nothing here needs
- * what that file spends its setup on.
- */
-const state = (): NodeJS.ProcessEnv => {
-  const dir = mkdtempSync(path.join(os.tmpdir(), 'notifai-caps-'))
-  return { HOME: dir, XDG_STATE_HOME: path.join(dir, 'state') } as NodeJS.ProcessEnv
-}
-
-describe('how many questions one session may hold', () => {
-  it('stops an agent registering a fifth question nobody has asked yet', () => {
-    const env = state()
-    for (let i = 0; i < MAX_PENDING_QUESTIONS; i += 1) {
-      registerQuestion('loop', env, { question: `Q${i}?` })
-    }
-    expect(() => registerQuestion('loop', env, { question: 'One more?' })).toThrow(
-      /already waiting to be asked/,
-    )
-  })
-
-  it('does not count a question the user simply has not answered yet', () => {
-    // An answer stays accepted for a day. Counting questions already on the
-    // user's devices against the loop guard would let a patient user stop the
-    // agent from asking anything at all.
-    const env = state()
-    for (let i = 0; i < MAX_PENDING_QUESTIONS; i += 1) {
-      registerQuestion('live', env, { question: `Asked ${i}?`, request_id: `req_${i}` })
-    }
-    expect(() => registerQuestion('live', env, { question: 'A new one?' })).not.toThrow()
-  })
-
-  it('still bounds what one session can put on the lock screen', () => {
-    const env = state()
-    for (let i = 0; i < MAX_LIVE_QUESTIONS; i += 1) {
-      registerQuestion('flood', env, { question: `Asked ${i}?`, request_id: `req_${i}` })
-    }
-    expect(() => registerQuestion('flood', env, { question: 'One too many?' })).toThrow(
-      /already open/,
-    )
-  })
-})

package/src/question-timing.ts

@@ -1,56 +0,0 @@
-import { REPLY_MAX_WINDOW_SECONDS } from '@raidiant/notifai-protocol'
-
-/**
- * Time before reply-window admission that the Stop owner may spend reading its
- * input, serving terminal-first grace, resolving devices, and submitting.
- *
- * Grace is capped at six minutes and every network operation is independently
- * bounded. Twenty minutes lets setup spend up to ten while preserving the
- * separate completion margin below; neither may borrow from the answer window
- * the service actually commits.
- */
-export const QUESTION_WAITER_STARTUP_HEADROOM_SECONDS = 20 * 60
-
-/**
- * Minimum lifetime still available when a question is admitted.
- *
- * The server window starts during submission, not when the hook process
- * started. Keeping ten minutes beyond the requested window covers the bounded
- * submit, clock skew, close fence, and route handoff. If setup used more of the
- * allowance, the frozen question remains local for a successor owner instead
- * of publishing a window this process cannot observe completely.
- */
-export const QUESTION_SUBMISSION_COMPLETION_HEADROOM_SECONDS = 10 * 60
-
-/**
- * The longest one Stop owner may live from process start.
- *
- * The service can accept an answer for up to 72 hours. Starting this budget
- * before submission is deliberate: the startup allowance above ensures that
- * even the maximum reply window still ends before the owner does.
- */
-export const QUESTION_WAITER_CEILING_SECONDS =
-  REPLY_MAX_WINDOW_SECONDS + QUESTION_WAITER_STARTUP_HEADROOM_SECONDS
-
-/** Time for final fencing, diagnostics, stdout handoff, and clean process exit. */
-export const QUESTION_STOP_TEARDOWN_HEADROOM_SECONDS = 60
-
-/**
- * Declared harness timeout for every Stop handler that owns Question Routing.
- * It must outlive the runtime owner; otherwise the harness silently kills the
- * only process capable of continuing the exact Agent Session.
- */
-export const QUESTION_STOP_TIMEOUT_SECONDS =
-  QUESTION_WAITER_CEILING_SECONDS + QUESTION_STOP_TEARDOWN_HEADROOM_SECONDS
-
-/**
- * Short Stop budget for harnesses that cannot own asynchronous Question
- * Routing. They retire/refuse promptly and never wait through an answer window.
- */
-export const NON_ROUTING_STOP_TIMEOUT_SECONDS = 540
-
-/**
- * Pre-PID claim files came only from the former eight-minute owner. Retain that
- * recovery bound instead of making a corrupt legacy file block for 72 hours.
- */
-export const LEGACY_QUESTION_CLAIM_TTL_SECONDS = 480

package/src/readiness.test.ts

@@ -1,25 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { refreshAfterMenuAction } from './readiness.js'
-
-describe('refreshAfterMenuAction', () => {
-  it('does not re-assess after doctor, a test send, or a device list', () => {
-    expect(refreshAfterMenuAction('doctor', true)).toBeNull()
-    expect(refreshAfterMenuAction('test', true)).toBeNull()
-    expect(refreshAfterMenuAction('devices', true)).toBeNull()
-  })
-
-  it('does not re-assess when the action changed nothing', () => {
-    expect(refreshAfterMenuAction('account', false)).toBeNull()
-    expect(refreshAfterMenuAction('settings', false)).toBeNull()
-    expect(refreshAfterMenuAction('routing', false)).toBeNull()
-    expect(refreshAfterMenuAction('setup', false)).toBeNull()
-  })
-
-  it('re-probes the service only after an action that can change it', () => {
-    expect(refreshAfterMenuAction('setup', true)).toEqual(['local', 'remote'])
-    expect(refreshAfterMenuAction('account', true)).toEqual(['local', 'remote'])
-    expect(refreshAfterMenuAction('settings', true)).toEqual(['local'])
-    expect(refreshAfterMenuAction('routing', true)).toEqual(['local'])
-    expect(refreshAfterMenuAction('settings', true, { remote: true })).toEqual(['local', 'remote'])
-  })
-})

package/src/readiness.ts

@@ -1,179 +0,0 @@
-/**
- * What "set up" means, in one place.
- *
- * `init` and `doctor` used to each carry their own idea of this — a fixed
- * five-step script in one, a flat list of checks in the other — which is two
- * copies of the same knowledge that can disagree, and did: doctor called
- * missing hooks fine while init offered to install them, and only doctor knew
- * what a revoked credential looked like.
- *
- * So the model lives here and both commands render it. `doctor` shows every
- * state at once, because a report is what it is for. `init` walks the same
- * list in order and stops at the first thing standing in the way, because
- * someone handed five tasks does none of them. An agent gets the same states
- * through a third renderer that never prompts.
- *
- * The ordering is a dependency chain, not a preference: there is no point
- * asking the server about devices before there is a credential to ask with,
- * and no point reporting a stale contract to someone who cannot reach the
- * server at all. Assessment stops descending when a prerequisite is missing
- * and marks what follows `unknown` rather than guessing.
- */
-
-/** Whether the gap can be closed from here, and by whom. */
-export type Remedy =
-  /**
-   * The CLI can do it unattended — no prompt, no human. `command` is how a
-   * reader would ask for it later, for the case where it was declined or
-   * skipped; it is never needed to perform the action.
-   */
-  | { by: 'cli'; summary: string; command?: string }
-  /**
-   * A human at this terminal. `interactive` marks the ones the CLI can drive
-   * on their behalf when someone is actually watching — a browser sign-in is
-   * the CLI's to launch but the human's to complete, so an agent must still
-   * treat it as out of reach.
-   */
-  | {
-      by: 'user-here'
-      summary: string
-      command: string
-      interactive?: boolean
-      /** Stable agent-facing description of an unavoidable harness-owned action. */
-      user_action?: { code: string; harness: string; action: string; message: string }
-    }
-  /**
-   * A human somewhere else entirely — phone in hand, app store, permission
-   * dialog. The class the old init could only print a sentence about, and the
-   * one most likely to end an onboarding.
-   */
-  | { by: 'user-elsewhere'; summary: string }
-
-export type StateStatus =
-  /** Satisfied. */
-  | 'ready'
-  /** Not satisfied, and it stands in the way. */
-  | 'gap'
-  /** Not satisfied, and that is a legitimate choice. */
-  | 'optional-gap'
-  /** A prerequisite is missing, so this was never evaluated. */
-  | 'unknown'
-
-export interface ReadinessState {
-  id: string
-  /** Human words for what this is, not the field name. */
-  title: string
-  status: StateStatus
-  /** The current condition, phrased for the human renderer. */
-  detail: string
-  /** Structured diagnostics emitted only by --json / non-human surfaces. */
-  technical?: unknown
-  remedy?: Remedy
-}
-
-export interface Readiness {
-  states: ReadinessState[]
-}
-
-/** The first thing standing in the way, or null when nothing is. */
-export function firstBlocker(readiness: Readiness): ReadinessState | null {
-  return readiness.states.find((s) => s.status === 'gap') ?? null
-}
-
-/**
- * Ready enough to be useful, which is not the same as every box ticked.
- *
- * Hooks and the agent skill are genuinely optional — `send` works without
- * them — so an install that declined both is finished, not half-done. Saying
- * otherwise trains people to ignore the summary line.
- */
-export function isReady(readiness: Readiness): boolean {
-  return firstBlocker(readiness) === null
-}
-
-const SEND_PREREQUISITES = new Set([
-  'cli-bin',
-  'credential',
-  'server',
-  'contract',
-  'auth',
-  'devices',
-])
-
-/** Baseline Notification Requests can be submitted in the final assessed state. */
-export function canSend(readiness: Readiness): boolean {
-  return [...SEND_PREREQUISITES].every((id) => {
-    const state = readiness.states.find((candidate) => candidate.id === id)
-    return state?.status === 'ready' || state?.status === 'optional-gap'
-  })
-}
-
-/** This exact invocation has a fully evidenced asynchronous question route. */
-export function questionRoutingReady(readiness: Readiness): boolean {
-  const relevant = readiness.states.filter(
-    (state) =>
-      state.id === 'question-routing-settings' ||
-      (state.id === 'hooks' || state.id.startsWith('hooks-')) && state.id !== 'hooks-detected',
-  )
-  return relevant.length > 0 && relevant.every((state) => state.status === 'ready')
-}
-
-/** Stable machine renderer shared by init and doctor. */
-export function readinessJson(readiness: Readiness): object {
-  return {
-    ready: isReady(readiness),
-    can_send: canSend(readiness),
-    question_routing_ready: questionRoutingReady(readiness),
-    states: readiness.states.map((state) => ({
-      id: state.id,
-      title: state.title,
-      status: state.status,
-      detail: state.detail,
-      technical: state.technical ?? null,
-      remedy: state.remedy ?? null,
-    })),
-  }
-}
-
-/** Everything that could still be done, blocking or not, in dependency order. */
-export function openItems(readiness: Readiness): ReadinessState[] {
-  return readiness.states.filter((s) => s.status === 'gap' || s.status === 'optional-gap')
-}
-
-/**
- * Work an assessment can do.
- *
- * `local` is this machine's files: project config, hook installs, skill lock
- * files. `remote` is everything that leaves the process — the keychain, the
- * service, the account, devices, and delivery evidence. The split exists so a
- * redraw after a settings change does not pay for a health check.
- */
-export type ReadinessRefresh = 'local' | 'remote'
-
-/**
- * After a menu action, which readiness work is worth doing.
- *
- * `null` means keep the assessment already in hand. Doctor is the report, not
- * a mutation: the check it just ran is the redraw. A test send and a device
- * list cannot change setup. Settings and hook wiring stay on this machine
- * unless the caller says the service URL itself moved.
- */
-export function refreshAfterMenuAction(
-  action: 'setup' | 'account' | 'test' | 'devices' | 'settings' | 'routing' | 'doctor',
-  changed: boolean,
-  options: { remote?: boolean } = {},
-): readonly ReadinessRefresh[] | null {
-  switch (action) {
-    case 'doctor':
-    case 'test':
-    case 'devices':
-      return null
-    case 'setup':
-    case 'account':
-      return changed ? ['local', 'remote'] : null
-    case 'settings':
-    case 'routing':
-      if (!changed) return null
-      return options.remote === true ? ['local', 'remote'] : ['local']
-  }
-}

package/src/release.ts

@@ -1,51 +0,0 @@
-import { readFileSync } from 'node:fs'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-/**
- * What this build is, according to the manifest npm actually shipped.
- *
- * Read from disk rather than compiled in, because a constant baked into
- * `dist/` is only ever as fresh as the last build. A stale `dist/` sitting
- * next to a newer `package.json` is a real failure mode — it produces a CLI
- * that reports the new version perfectly while running the old code — and the
- * only defence that survives it is refusing to carry a second copy of the
- * number at all.
- *
- * The manifest sits one level above both `src/` and `dist/`, so a single
- * relative path resolves in a source checkout and in a published install.
- *
- * Returns null rather than guessing: a build that cannot establish its own
- * identity has to say so, so callers can degrade honestly instead of
- * asserting something they do not know.
- */
-export function packageVersion(): string | null {
-  try {
-    const manifest = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'package.json')
-    const parsed: unknown = JSON.parse(readFileSync(manifest, 'utf8'))
-    if (typeof parsed === 'object' && parsed !== null) {
-      const { version } = parsed as { version?: unknown }
-      if (typeof version === 'string' && version.length > 0) return version
-    }
-  } catch {
-    // Fall through: an unreadable manifest must not stop the CLI running.
-  }
-  return null
-}
-
-/**
- * Where `npx skills add` fetches the agent skill from, as printed to users.
- *
- * Always an immutable tag naming this exact build. The skill and the CLI ship
- * from one repository at one version, and the skill describes how to drive the
- * CLI — so a moving ref would hand someone guidance for a tool they do not
- * have. Deriving it from the version is what keeps the two from disagreeing;
- * it used to be maintained by hand in three places, and the copies drifted.
- *
- * In the skills CLI grammar `owner/repo#ref` selects a Git ref, while
- * `owner/repo@name` selects a skill — so the `#` here is load-bearing.
- */
-export function skillsSource(): string | null {
-  const version = packageVersion()
-  return version === null ? null : `Raidiant-io/notifai#v${version}`
-}

package/src/send-attempts.test.ts

@@ -1,143 +0,0 @@
-import { mkdtempSync, readFileSync, readdirSync, rmSync, statSync, symlinkSync, writeFileSync } from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { afterEach, describe, expect, it } from 'vitest'
-import type { NotificationDraftT } from '@raidiant/notifai-protocol'
-import type { MachineCredential } from './credentials.js'
-import {
-  SEND_ATTEMPT_TTL_MS,
-  beginSendAttempt,
-  semanticMediaIds,
-  sendDraftFingerprint,
-  settleSendAttempt,
-} from './send-attempts.js'
-
-const roots: string[] = []
-afterEach(() => {
-  while (roots.length > 0) rmSync(roots.pop()!, { recursive: true, force: true })
-})
-
-function fixture() {
-  const root = mkdtempSync(path.join(os.tmpdir(), 'notifai-send-attempt-'))
-  roots.push(root)
-  const env = { XDG_STATE_HOME: path.join(root, 'state') }
-  const credential: MachineCredential = {
-    machineId: 'mac_attempt',
-    machineName: 'Attempt Machine',
-    baseUrl: 'https://app.notifai.test',
-    secret: 'private-machine-secret',
-  }
-  const draft = {
-    schema_version: 1,
-    kind: 'done',
-    project: 'private-project',
-    presentation: { title: 'Sensitive result', body: 'Private body text' },
-    targets: { mode: 'all' },
-  } as NotificationDraftT
-  return { root, env, credential, draft }
-}
-
-describe('opaque interrupted-send recovery', () => {
-  it('matches one exact semantic retry without storing notification content', () => {
-    const { env, credential, draft } = fixture()
-    const fingerprint = sendDraftFingerprint(draft, credential)
-    const first = beginSendAttempt({ env, credential, fingerprint, retry: false, now: 10 })
-    expect(first.ok).toBe(true)
-    if (!first.ok) return
-
-    const files = readdirSync(path.join(env.XDG_STATE_HOME, 'notifai', 'send-attempts'))
-    expect(files).toHaveLength(1)
-    const file = path.join(env.XDG_STATE_HOME, 'notifai', 'send-attempts', files[0]!)
-    const stored = readFileSync(file, 'utf8')
-    expect(stored).not.toContain('Sensitive result')
-    expect(stored).not.toContain('Private body text')
-    if (process.platform !== 'win32') expect(statSync(file).mode & 0o777).toBe(0o600)
-    if (process.platform !== 'win32') {
-      expect(statSync(path.dirname(file)).mode & 0o777).toBe(0o700)
-    }
-
-    const retry = beginSendAttempt({ env, credential, fingerprint, retry: true, now: 11 })
-    expect(retry).toMatchObject({
-      ok: true,
-      attemptId: first.attemptId,
-      idempotencyKey: first.idempotencyKey,
-      replay: true,
-    })
-    settleSendAttempt(env, first.attemptId)
-    expect(beginSendAttempt({ env, credential, fingerprint, retry: true, now: 12 })).toMatchObject({
-      ok: false,
-      code: 'retry_not_found',
-    })
-  })
-
-  it('does not follow a symlink presented as an attempt record', () => {
-    const { root, env, credential, draft } = fixture()
-    if (process.platform === 'win32') return
-    const fingerprint = sendDraftFingerprint(draft, credential)
-    const first = beginSendAttempt({ env, credential, fingerprint, retry: false, now: 10 })
-    expect(first.ok).toBe(true)
-    if (!first.ok) return
-    const directory = path.join(env.XDG_STATE_HOME, 'notifai', 'send-attempts')
-    const file = path.join(directory, `${first.attemptId}.json`)
-    const target = path.join(root, 'foreign.json')
-    writeFileSync(target, readFileSync(file, 'utf8'))
-    rmSync(file)
-    symlinkSync(target, file)
-
-    expect(beginSendAttempt({ env, credential, fingerprint, retry: true, now: 11 })).toMatchObject({
-      ok: false,
-      code: 'retry_not_found',
-    })
-    expect(readFileSync(target, 'utf8')).toContain(first.idempotencyKey)
-  })
-
-  it('refuses ambiguity instead of choosing between identical unresolved events', () => {
-    const { env, credential, draft } = fixture()
-    const fingerprint = sendDraftFingerprint(draft, credential)
-    beginSendAttempt({ env, credential, fingerprint, retry: false, now: 10 })
-    beginSendAttempt({ env, credential, fingerprint, retry: false, now: 11 })
-    expect(beginSendAttempt({ env, credential, fingerprint, retry: true, now: 12 })).toMatchObject({
-      ok: false,
-      code: 'retry_ambiguous',
-    })
-  })
-
-  it('invalidates attempts after expiry or credential rotation', () => {
-    const { env, credential, draft } = fixture()
-    const fingerprint = sendDraftFingerprint(draft, credential)
-    beginSendAttempt({ env, credential, fingerprint, retry: false, now: 10 })
-    expect(
-      beginSendAttempt({
-        env,
-        credential,
-        fingerprint,
-        retry: true,
-        now: 10 + SEND_ATTEMPT_TTL_MS + 1,
-      }),
-    ).toMatchObject({ ok: false, code: 'retry_not_found' })
-
-    beginSendAttempt({ env, credential, fingerprint, retry: false, now: 20 })
-    const rotated = { ...credential, secret: 'rotated-secret' }
-    expect(
-      beginSendAttempt({
-        env,
-        credential: rotated,
-        fingerprint: sendDraftFingerprint(draft, rotated),
-        retry: true,
-        now: 21,
-      }),
-    ).toMatchObject({ ok: false, code: 'retry_not_found' })
-  })
-
-  it('fingerprints local media bytes without retaining paths or bytes', () => {
-    const { root } = fixture()
-    const file = path.join(root, 'private.png')
-    writeFileSync(file, 'first bytes')
-    const first = semanticMediaIds([file], root)
-    writeFileSync(file, 'different bytes')
-    const second = semanticMediaIds([file], root)
-    expect(first).not.toEqual(second)
-    expect(first[0]).not.toContain(file)
-    expect(first[0]).not.toContain('first bytes')
-  })
-})