@raidiant/notifai 10.1.0 → 10.1.2

package/src/opencode-plugin.ts

@@ -1,298 +0,0 @@
-import path from 'node:path'
-import { hookHostPlatform, type HookHostPlatform } from './hook-adapter.js'
-import { configHome } from './install-hooks.js'
-import {
-  MISSING_LIFECYCLE_GUIDANCE_CONTEXT,
-  WORKER_ACTIVATION_CONTEXT,
-} from './session-activation.js'
-
-/**
- * The OpenCode adapter.
- *
- * OpenCode's extension point is a TypeScript/JavaScript plugin module, not a
- * command hook, so it needs a different adapter rather than a different path
- * through the existing one. What it is *not* is different logic: the generated
- * plugin shells out to the same `notifai hook <event>` commands Claude Code and
- * Codex invoke, and every decision — presence, the grace window, the reply
- * wait, retirement — stays in one place.
- *
- * The three lifecycle joints map onto the same three events. OpenCode exposes
- * `chat.message` as a direct hook, while session lifecycle notifications arrive
- * through its generic `event` hook:
- *
- *   chat.message   -> user-prompt-submit   (the user is at the keyboard)
- *   session.idle   -> stop                 (the turn ended; escalate)
- *   session.deleted -> session-end         (retire local session state)
- *
- * Permission prompts deliberately stay in OpenCode. The CLI question flow
- * only escalates questions explicitly registered with `notifai ask`.
- */
-
-/** Marker line; also how an install from another checkout is recognised. */
-export const OPENCODE_PLUGIN_MARKER = '// notifai managed opencode plugin'
-
-/** Filename we own inside whichever plugins directory is being written. */
-export const OPENCODE_PLUGIN_FILENAME = 'notifai.js'
-
-/** Bump when an installed generated file must be rewritten to remain functional. */
-const OPENCODE_ADAPTER_VERSION = 12
-
-export function opencodePluginDir(
-  global: boolean,
-  cwd: string,
-  env: NodeJS.ProcessEnv = process.env,
-  platform: NodeJS.Platform | HookHostPlatform = process.platform,
-): string {
-  return global
-    ? path.join(configHome(env, 'OPENCODE_CONFIG_DIR', '.config/opencode', platform), 'plugins')
-    : path.join(cwd, '.opencode', 'plugins')
-}
-
-export function opencodePluginPath(
-  global: boolean,
-  cwd: string,
-  env: NodeJS.ProcessEnv = process.env,
-  platform: NodeJS.Platform | HookHostPlatform = process.platform,
-): string {
-  return path.join(opencodePluginDir(global, cwd, env, platform), OPENCODE_PLUGIN_FILENAME)
-}
-
-export interface OpencodePluginOptions {
-  /** The same stable user-level adapter every command-hook harness invokes. */
-  adapterPath: string
-  /** Child-process lifetime; covers grace, reply wait, and teardown headroom. */
-  timeoutSeconds: number
-  platform?: NodeJS.Platform | HookHostPlatform
-  /** Registered Node used to interpret the Windows adapter. Ignored on POSIX. */
-  nodePath?: string
-}
-
-/**
- * The generated module.
- *
- * Written as a string rather than compiled from a source file because OpenCode
- * loads a plugin module rather than a command definition. It embeds only the
- * stable user-level adapter path; mutable runtime and CLI targets live behind
- * that adapter exactly as they do for every other harness.
- *
- * Everything it does is build the hook envelope OpenCode's event gives it and
- * hand that to the CLI on stdin. It deliberately fails open: an adapter error
- * never changes OpenCode's own behavior.
- */
-/**
- * The plugin body, which is the same on every platform except for how it
- * reaches the adapter.
- *
- * It was two near-identical copies — about a hundred and twenty lines each,
- * differing only in the spawn call — so every fix to the plugin had to be made
- * twice or silently apply to one platform.
- */
-export function opencodePluginSource(options: OpencodePluginOptions): string {
-  const { adapterPath, timeoutSeconds } = options
-  // Windows cannot execute the adapter script directly, so it goes through the
-  // registered Node executable and the console window is suppressed.
-  const win32 = hookHostPlatform(options.platform) === 'win32'
-  const nodeConstant = win32
-    ? `const NODE = ${JSON.stringify(options.nodePath ?? process.execPath)}\n`
-    : ''
-  const spawnArguments = win32
-    ? 'NODE, [ADAPTER, "hook", event, "--owner", "notifai", "--harness", "opencode"]'
-    : 'ADAPTER, ["hook", event, "--owner", "notifai", "--harness", "opencode"]'
-  const windowsHide = win32 ? '\n        windowsHide: true,' : ''
-  return `${OPENCODE_PLUGIN_MARKER}
-// Generated by \`notifai hooks install --harness opencode\`. Edits are lost on
-// the next install; change the CLI instead, which is where the logic lives.
-import { spawn } from "node:child_process"
-
-${nodeConstant}const ADAPTER = ${JSON.stringify(adapterPath)}
-const TIMEOUT_MS = ${timeoutSeconds * 1000}
-const ADAPTER_VERSION = ${OPENCODE_ADAPTER_VERSION}
-const MISSING_LIFECYCLE_GUIDANCE_CONTEXT = ${JSON.stringify(MISSING_LIFECYCLE_GUIDANCE_CONTEXT)}
-const WORKER_ACTIVATION_CONTEXT = ${JSON.stringify(WORKER_ACTIVATION_CONTEXT)}
-const PENDING_SESSION_TITLE =
-  /^New session(?: *- *[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(?:[.][0-9]+)?Z)?$/i
-
-/**
- * Runs \`notifai hook <event>\`, feeding it the same JSON envelope the other
- * harnesses send. Resolves to stdout, or null if anything at all went wrong.
- */
-function runHook(event, envelope) {
-  return new Promise((resolve) => {
-    let child
-    try {
-      child = spawn(${spawnArguments}, {
-        env: process.env,
-        shell: false,${windowsHide}
-        stdio: ["pipe", "pipe", "pipe"],
-      })
-    } catch {
-      resolve(null)
-      return
-    }
-
-    let stdout = ""
-    let settled = false
-    const finish = (value) => {
-      if (settled) return
-      settled = true
-      clearTimeout(timer)
-      resolve(value)
-    }
-    const timer = setTimeout(() => {
-      child.kill("SIGTERM")
-      finish(null)
-    }, TIMEOUT_MS)
-
-    child.stdout?.setEncoding("utf-8")
-    child.stdout?.on("data", (chunk) => {
-      stdout += chunk
-    })
-    // Hook stderr is diagnostics, not plugin output; discard it here.
-    child.stderr?.resume()
-    child.on("error", () => finish(null))
-    child.on("close", () => finish(stdout))
-
-    try {
-      child.stdin?.end(JSON.stringify(envelope))
-    } catch {
-      finish(null)
-    }
-  })
-}
-
-export const NotifAIPlugin = async ({ directory, client }) => {
-  const cwd = typeof directory === "string" && directory.length > 0 ? directory : process.cwd()
-  const activated = new Set()
-
-  return {
-    /** Model-visible activation, independent of CLI setup and delivery state. */
-    "experimental.chat.system.transform": async (input, output) => {
-      const sessionID = input?.sessionID
-      if (typeof sessionID !== "string" || sessionID.length === 0) return
-      if (activated.has(sessionID)) return
-      // OpenCode represents delegated work as child sessions. Missing or
-      // malformed relationship data must fail closed as worker context: it is
-      // safe to suppress a notification, never safe to let a child duplicate
-      // its parent's User-visible request.
-      let worker = true
-      try {
-        const response = await client.session.get({ path: { id: sessionID } })
-        const session = response?.data
-        if (session !== null && typeof session === "object") {
-          worker = typeof session.parentID === "string" && session.parentID.length > 0
-        }
-      } catch {
-        // Keep the safe worker classification.
-      }
-      const hookEventName = worker ? "SubagentStart" : "SessionStart"
-      const resolved = await runHook(worker ? "subagent-start" : "session-start", {
-        session_id: sessionID,
-        cwd,
-        hook_event_name: hookEventName,
-      })
-      const context = typeof resolved === "string" && resolved.trim().length > 0
-        ? resolved.trim()
-        : worker ? WORKER_ACTIVATION_CONTEXT : MISSING_LIFECYCLE_GUIDANCE_CONTEXT
-      if (output.system.length === 0) {
-        output.system.push(context)
-      } else {
-        output.system[0] = output.system[0] + "\\n\\n" + context
-      }
-      activated.add(sessionID)
-    },
-
-    /** Exact active-harness identity and first-party title for agent shell commands. */
-    "shell.env": async (input, output) => {
-      output.env.NOTIFAI_ACTIVE_HARNESS = "opencode"
-      const sessionID = input?.sessionID
-      if (typeof sessionID === "string" && sessionID.length > 0) {
-        output.env.NOTIFAI_ACTIVE_SESSION_ID = sessionID
-        try {
-          const response = await client.session.get({ path: { id: sessionID } })
-          const title = response?.data?.title
-          if (typeof title === "string" && title.trim().length > 0) {
-            if (PENDING_SESSION_TITLE.test(title.trim())) {
-              output.env.NOTIFAI_ACTIVE_SESSION_LABEL_PENDING = "1"
-            } else {
-              output.env.NOTIFAI_ACTIVE_SESSION_LABEL = title
-            }
-          }
-        } catch {
-          // Identity remains useful when this OpenCode build cannot expose a title.
-        }
-      }
-    },
-
-    /**
-     * Presence. The user typing is the signal every harness shares, and it is
-     * also what publishes the project -> session pointer \`notifai ask\` reads.
-     */
-    /** Publishes the session pointer; the CLI returns no content to inject. */
-    "chat.message": async (input) => {
-      await runHook("user-prompt-submit", {
-        session_id: input?.sessionID ?? input?.info?.sessionID,
-        cwd,
-        hook_event_name: "UserPromptSubmit",
-      })
-    },
-
-    /** Session lifecycle events are delivered through OpenCode's event bus. */
-    event: async ({ event }) => {
-      if (event?.type === "session.idle") {
-        await runHook("stop", {
-          session_id: event?.properties?.sessionID,
-          cwd,
-          hook_event_name: "Stop",
-        })
-      } else if (event?.type === "session.deleted") {
-        await runHook("session-end", {
-          session_id: event?.properties?.info?.id,
-          cwd,
-          hook_event_name: "SessionEnd",
-        })
-      }
-    },
-  }
-}
-`
-}
-
-/** True when a plugin file on disk is one of ours, whoever installed it. */
-export function isOurOpencodePlugin(contents: string): boolean {
-  return contents.includes(OPENCODE_PLUGIN_MARKER)
-}
-
-/**
- * The interpreter and script a generated plugin will actually run.
- *
- * A plugin is a module rather than a command line, so which *build* it invokes
- * is not visible in the way it is for a settings-file handler — it is baked
- * into the two constants at the top. `doctor` needs it to answer the question
- * it exists to answer ("are two checkouts both installed?"), and without it
- * the plugin's own path stands in for the build and every OpenCode install
- * looks like a second one.
- *
- * Returns null for a plugin we did not generate, or one whose constants have
- * been edited out of recognisable shape.
- */
-export function opencodePluginTarget(
-  contents: string,
-): { adapter: string; current: boolean; timeoutSeconds?: number; nodePath?: string } | null {
-  if (!isOurOpencodePlugin(contents)) return null
-  const adapter = /^const ADAPTER = (".*")$/m.exec(contents)?.[1]
-  const legacyScript = /^const SCRIPT = (".*")$/m.exec(contents)?.[1]
-  const node = /^const NODE = (".*")$/m.exec(contents)?.[1]
-  const version = Number(/^const ADAPTER_VERSION = (\d+)$/m.exec(contents)?.[1] ?? 1)
-  const timeoutMs = Number(/^const TIMEOUT_MS = (\d+)$/m.exec(contents)?.[1] ?? Number.NaN)
-  if (adapter === undefined && legacyScript === undefined) return null
-  try {
-    return {
-      adapter: JSON.parse(adapter ?? legacyScript!) as string,
-      current: version === OPENCODE_ADAPTER_VERSION,
-      ...(Number.isFinite(timeoutMs) ? { timeoutSeconds: timeoutMs / 1000 } : {}),
-      ...(node === undefined ? {} : { nodePath: JSON.parse(node) as string }),
-    }
-  } catch {
-    return null
-  }
-}

package/src/orca-session-title.test.ts

@@ -1,54 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { readOrcaSessionTitle, type OrcaCommand } from './orca-session-title.js'
-
-const worktreeId = 'repo-123::/worktrees/agent-session-labels'
-
-function response(overrides: Record<string, unknown> = {}): string {
-  return JSON.stringify({
-    ok: true,
-    result: {
-      worktree: {
-        id: worktreeId,
-        path: '/worktrees/agent-session-labels',
-        displayName: 'Agent Session context labels',
-        ...overrides,
-      },
-    },
-  })
-}
-
-describe('Orca Agent Session title context', () => {
-  it('accepts only the User-facing title returned for the exact managed worktree', () => {
-    const calls: { executable: string; args: readonly string[] }[] = []
-    const command: OrcaCommand = (executable, args) => {
-      calls.push({ executable, args })
-      return response()
-    }
-
-    expect(
-      readOrcaSessionTitle({ TERM_PROGRAM: 'Orca', ORCA_WORKTREE_ID: worktreeId }, command),
-    ).toBe('Agent Session context labels')
-    expect(calls).toEqual([
-      {
-        executable: 'orca',
-        args: ['worktree', 'show', '--worktree', `id:${worktreeId}`, '--json'],
-      },
-    ])
-  })
-
-  it.each([
-    ['command failure', () => null],
-    ['malformed JSON', () => '{not json}'],
-    ['failed response', () => JSON.stringify({ ok: false })],
-    ['different worktree id', () => response({ id: 'repo-123::/worktrees/other' })],
-    ['different worktree path', () => response({ path: '/private/untrusted' })],
-    ['blank display name', () => response({ displayName: '   ' })],
-  ])('leaves the generated fallback exceptional when context is unavailable: %s', (_name, command) => {
-    expect(
-      readOrcaSessionTitle(
-        { TERM_PROGRAM: 'Orca', ORCA_WORKTREE_ID: worktreeId },
-        command,
-      ),
-    ).toBeUndefined()
-  })
-})

package/src/orca-session-title.ts

@@ -1,103 +0,0 @@
-import { execFileSync } from 'node:child_process'
-import path from 'node:path'
-
-export type OrcaSessionTitleLookup = (env: NodeJS.ProcessEnv) => string | undefined
-export type OrcaCommand = (executable: string, args: readonly string[]) => string | null
-
-const runOrcaCommand: OrcaCommand = (executable, args) => {
-  try {
-    return execFileSync(executable, args, {
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-      timeout: 2_000,
-      maxBuffer: 512 * 1024,
-      windowsHide: true,
-    }).trim()
-  } catch {
-    return null
-  }
-}
-
-function containsControlCharacter(value: string): boolean {
-  return Array.from(value).some((character) => {
-    const codePoint = character.codePointAt(0) ?? 0
-    return codePoint < 32 || codePoint === 127
-  })
-}
-
-function worktreePathFromId(value: string): string | null {
-  if (value.length === 0 || value.length > 4_096 || containsControlCharacter(value)) return null
-  const separator = value.indexOf('::')
-  if (separator <= 0) return null
-  const repoId = value.slice(0, separator)
-  const worktreePath = value.slice(separator + 2)
-  if (!/^[A-Za-z0-9._-]+$/u.test(repoId) || worktreePath.length === 0) return null
-  return path.posix.isAbsolute(worktreePath) || path.win32.isAbsolute(worktreePath)
-    ? worktreePath
-    : null
-}
-
-function orcaExecutable(env: NodeJS.ProcessEnv): string | null {
-  const configured = env['ORCA_CLI_COMMAND']?.trim()
-  if (configured !== undefined && configured.length > 0) {
-    return containsControlCharacter(configured) ? null : configured
-  }
-  return env['ORCA_DEV_REPO_ROOT'] === undefined ? 'orca' : 'orca-dev'
-}
-
-/**
- * Read the User-facing task name assigned to this exact Orca worktree.
- *
- * The environment contributes only an opaque selector. Orca must return that
- * exact id and its matching path before its display name becomes trusted; no
- * path component or identifier is ever promoted into an Agent Session label.
- */
-export function readOrcaSessionTitle(
-  env: NodeJS.ProcessEnv,
-  command: OrcaCommand = runOrcaCommand,
-): string | undefined {
-  if (env['TERM_PROGRAM'] !== 'Orca') return undefined
-  const worktreeId = env['ORCA_WORKTREE_ID']
-  if (worktreeId === undefined) return undefined
-  const expectedPath = worktreePathFromId(worktreeId)
-  if (expectedPath === null) return undefined
-  const executable = orcaExecutable(env)
-  if (executable === null) return undefined
-
-  let output: string | null
-  try {
-    output = command(executable, [
-      'worktree',
-      'show',
-      '--worktree',
-      `id:${worktreeId}`,
-      '--json',
-    ])
-  } catch {
-    return undefined
-  }
-  if (output === null || output === '') return undefined
-
-  let parsed: unknown
-  try {
-    parsed = JSON.parse(output)
-  } catch {
-    return undefined
-  }
-  if (typeof parsed !== 'object' || parsed === null) return undefined
-  const response = parsed as {
-    ok?: unknown
-    result?: { worktree?: { id?: unknown; path?: unknown; displayName?: unknown } }
-  }
-  const worktree = response.result?.worktree
-  if (
-    response.ok !== true ||
-    worktree?.id !== worktreeId ||
-    worktree.path !== expectedPath ||
-    typeof worktree.displayName !== 'string' ||
-    worktree.displayName.trim().length === 0
-  ) {
-    return undefined
-  }
-  return worktree.displayName
-}

package/src/pack-feedback-slice.test.ts

@@ -1,212 +0,0 @@
-import { randomBytes } from 'node:crypto'
-import { appendFileSync, mkdirSync, mkdtempSync, writeFileSync } from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { gunzipSync } from 'node:zlib'
-import { describe, expect, it } from 'vitest'
-import { LOG_SCHEMA_VERSION, activeLogPath, createLogger, type LogRecord } from './logging.js'
-import { encodeFeedbackSlice, packFeedbackSlice } from './pack-feedback-slice.js'
-
-function sandbox(): NodeJS.ProcessEnv {
-  return { XDG_STATE_HOME: mkdtempSync(path.join(os.tmpdir(), 'notifai-feedback-')) }
-}
-
-function writeLog(env: NodeJS.ProcessEnv, records: LogRecord[]): void {
-  const file = activeLogPath(env)
-  mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 })
-  writeFileSync(file, `${records.map((record) => JSON.stringify(record)).join('\n')}\n`, {
-    mode: 0o600,
-  })
-}
-
-function record(overrides: Partial<LogRecord> & Pick<LogRecord, 'ts'>): LogRecord {
-  return {
-    v: 1,
-    level: 'info',
-    event: 'cli.end',
-    run: 'r_1',
-    cmd: 'send',
-    pid: 1,
-    ...overrides,
-  }
-}
-
-describe('packFeedbackSlice', () => {
-  it('returns an empty result with no gzip when there is no log', () => {
-    const result = packFeedbackSlice(sandbox())
-
-    expect(result.record_count).toBe(0)
-    expect(result.records).toEqual([])
-    expect(result.jsonl).toBe('')
-    expect(result.gzip).toBeUndefined()
-    expect(result.uncompressed_bytes).toBe(0)
-    expect(result.compressed_bytes).toBe(0)
-    expect(result.truncated).toBe(false)
-    expect(result.consentSummary.toLowerCase()).toMatch(/credential/)
-    expect(result.consentSummary.toLowerCase()).toMatch(/title/)
-    expect(result.consentSummary.toLowerCase()).toMatch(/answer/)
-  })
-
-  it('packs records inside the default 24-hour window and drops older ones', () => {
-    const env = sandbox()
-    const now = Date.parse('2026-08-13T12:00:00.000Z')
-    writeLog(env, [
-      record({ ts: '2026-08-12T11:00:00.000Z', data: { which: 'too-old' } }),
-      record({ ts: '2026-08-12T13:00:00.000Z', data: { which: 'kept' } }),
-    ])
-
-    const result = packFeedbackSlice(env, { now })
-
-    expect(result.record_count).toBe(1)
-    expect(result.records[0]?.data).toMatchObject({ which: 'kept' })
-    expect(result.since).toBe(Date.parse('2026-08-12T12:00:00.000Z'))
-    expect(result.until).toBe(now)
-    expect(result.jsonl).toContain('kept')
-    expect(result.jsonl).not.toContain('too-old')
-    expect(result.gzip).toBeDefined()
-    expect(result.uncompressed_bytes).toBe(Buffer.byteLength(result.jsonl))
-    expect(result.compressed_bytes).toBe(result.gzip!.length)
-    expect(result.truncated).toBe(false)
-  })
-
-  it('gives consent copy that names redacted credentials, titles, answers, window, and size', () => {
-    const env = sandbox()
-    const now = Date.parse('2026-08-13T12:00:00.000Z')
-    writeLog(env, [record({ ts: '2026-08-13T11:00:00.000Z' })])
-
-    const result = packFeedbackSlice(env, { now })
-    const copy = result.consentSummary.toLowerCase()
-
-    expect(copy).toMatch(/credential/)
-    expect(copy).toMatch(/already removed|already redacted|redacted/)
-    expect(copy).toMatch(/title/)
-    expect(copy).toMatch(/answer/)
-    expect(result.consentSummary).toContain('2026-08-12T12:00:00.000Z')
-    expect(result.consentSummary).toContain('2026-08-13T12:00:00.000Z')
-    expect(result.consentSummary).toContain(String(result.uncompressed_bytes))
-    expect(result.consentSummary).toContain(String(result.compressed_bytes))
-    expect(result.consentSummary).toContain(String(result.record_count))
-  })
-
-  it('applies extra log query filters on top of the window', () => {
-    const env = sandbox()
-    const now = Date.parse('2026-08-13T12:00:00.000Z')
-    writeLog(env, [
-      record({ ts: '2026-08-13T11:00:00.000Z', event: 'cli.end', data: { which: 'end' } }),
-      record({ ts: '2026-08-13T11:01:00.000Z', event: 'cli.error', data: { which: 'error' } }),
-    ])
-
-    const result = packFeedbackSlice(env, { now, event: ['cli.error'] })
-
-    expect(result.record_count).toBe(1)
-    expect(result.records[0]?.event).toBe('cli.error')
-    expect(result.records[0]?.data).toMatchObject({ which: 'error' })
-  })
-
-  it('drops oldest records until the uncompressed JSONL cap holds', () => {
-    const env = sandbox()
-    const now = Date.parse('2026-08-13T12:00:00.000Z')
-    const start = Date.parse('2026-08-13T10:00:00.000Z')
-    const pad = 'x'.repeat(2000)
-    writeLog(
-      env,
-      Array.from({ length: 200 }, (_, sequence) =>
-        record({
-          ts: new Date(start + sequence * 1000).toISOString(),
-          data: { sequence, pad },
-        }),
-      ),
-    )
-
-    const result = packFeedbackSlice(env, { now })
-    const sequences = result.records.map((entry) => entry.data?.['sequence'])
-
-    expect(result.uncompressed_bytes).toBeLessThanOrEqual(256 * 1024)
-    expect(result.compressed_bytes).toBeLessThanOrEqual(128 * 1024)
-    expect(result.truncated).toBe(true)
-    expect(result.record_count).toBeGreaterThan(0)
-    expect(sequences[0]).toBeGreaterThan(0)
-    expect(sequences.at(-1)).toBe(199)
-  })
-
-  it('drops oldest records until the gzip cap holds', () => {
-    const env = sandbox()
-    const now = Date.parse('2026-08-13T12:00:00.000Z')
-    const start = Date.parse('2026-08-13T10:00:00.000Z')
-    const seeded = Array.from({ length: 80 }, (_, sequence) =>
-      record({
-        ts: new Date(start + sequence * 1000).toISOString(),
-        data: { sequence, pad: randomBytes(1800).toString('base64') },
-      }),
-    )
-    writeLog(env, seeded)
-
-    const result = packFeedbackSlice(env, { now })
-    const sequences = result.records.map((entry) => entry.data?.['sequence'])
-
-    expect(result.uncompressed_bytes).toBeLessThanOrEqual(256 * 1024)
-    expect(result.compressed_bytes).toBeLessThanOrEqual(128 * 1024)
-    expect(result.truncated).toBe(true)
-    expect(result.record_count).toBeGreaterThan(0)
-    expect(result.record_count).toBeLessThan(seeded.length)
-    expect(sequences[0]).toBeGreaterThan(0)
-    expect(sequences.at(-1)).toBe(79)
-  })
-
-  it('encodes the gzip slice as a gzip+base64 wire payload', () => {
-    const env = sandbox()
-    const now = Date.parse('2026-08-13T12:00:00.000Z')
-    writeLog(env, [record({ ts: '2026-08-13T11:00:00.000Z', data: { which: 'wire' } })])
-
-    const packed = packFeedbackSlice(env, { now })
-    const wire = encodeFeedbackSlice(packed)
-
-    expect(wire).toEqual({
-      encoding: 'gzip+base64',
-      bytes: packed.gzip!.toString('base64'),
-      uncompressed_bytes: packed.uncompressed_bytes,
-      compressed_bytes: packed.compressed_bytes,
-      record_count: packed.record_count,
-      truncated: false,
-      since: '2026-08-12T12:00:00.000Z',
-      until: '2026-08-13T12:00:00.000Z',
-      schema_version: packed.schema_version,
-    })
-    expect(gunzipSync(Buffer.from(wire!.bytes, 'base64')).toString('utf8')).toBe(packed.jsonl)
-    expect(encodeFeedbackSlice(packFeedbackSlice(sandbox()))).toBeUndefined()
-  })
-
-  it('honours an explicit since instead of the 24-hour default', () => {
-    const env = sandbox()
-    const now = Date.parse('2026-08-13T12:00:00.000Z')
-    writeLog(env, [
-      record({ ts: '2026-08-10T12:00:00.000Z', data: { which: 'old' } }),
-      record({ ts: '2026-08-13T11:00:00.000Z', data: { which: 'new' } }),
-    ])
-
-    const result = packFeedbackSlice(env, {
-      now,
-      since: Date.parse('2026-08-10T00:00:00.000Z'),
-    })
-
-    expect(result.records.map((entry) => entry.data?.['which'])).toEqual(['old', 'new'])
-    expect(result.since).toBe(Date.parse('2026-08-10T00:00:00.000Z'))
-  })
-
-  it('packs records written by the logger and skips a damaged line', () => {
-    const env = sandbox()
-    const logger = createLogger({ env, now: () => Date.parse('2026-08-13T11:30:00.000Z') })
-    logger.info('cli.end', { which: 'first' })
-    appendFileSync(activeLogPath(env), 'not json at all\n')
-    createLogger({ env, now: () => Date.parse('2026-08-13T11:31:00.000Z') }).info('cli.end', {
-      which: 'second',
-    })
-
-    const result = packFeedbackSlice(env, { now: Date.parse('2026-08-13T12:00:00.000Z') })
-
-    expect(result.schema_version).toBe(LOG_SCHEMA_VERSION)
-    expect(result.record_count).toBe(2)
-    expect(result.records.map((entry) => entry.data?.['which'])).toEqual(['first', 'second'])
-    expect(result.truncated).toBe(false)
-  })
-})