previous_response_id 404s once the parent has aged out

"""Walk recorded previous_response_id chains and find the links already gone.

Read only. One GET of /v1/responses/{response_id} per link, and nothing else.
No completion is created, nothing is stored and nothing is deleted.

Response objects are saved for 30 days by default, so a chain is exactly as
durable as its oldest surviving link. This walks upward from the newest id you
recorded to a root or to a gap, and reports the runway from the oldest link
rather than from the newest.

The one documented exception is also the repair: a response attached to a
conversation has its items persisted with no 30 day TTL, so a conversation
backed chain keeps its history whatever happens to the response objects.

/v1/responses has no list endpoint, so the ids come from your own records and
every verdict is bounded by the chains you supply.
"""
import argparse
import logging
import os
import sys
import time

import requests

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
log = logging.getLogger("openai_response_chain_probe")

BASE_URL = "https://api.openai.com/v1/responses"

# The documented default: response objects are saved for 30 days.
RETENTION_DAYS = 30

FINDINGS = ("chain-broken", "chain-expiring", "chain-unreadable")


def parse_ids(text):
    """Response ids from a file. Pure. Blanks, comments and repeats dropped."""
    seen = []
    for line in str(text or "").splitlines():
        item = line.split("#", 1)[0].strip()
        if item and item not in seen:
            seen.append(item)
    return seen


def link_row(body):
    """One retrieved response, reduced. Pure. Four fields and no invention.

    There is deliberately no "stored" field here. The Response object does not
    carry a store flag, so the only honest evidence that a response was stored
    is that retrieving it worked, and that is recorded as the status code.
    """
    body = body if isinstance(body, dict) else {}
    conversation = body.get("conversation")
    if isinstance(conversation, dict):
        conversation = conversation.get("id")
    try:
        created = int(body.get("created_at") or 0)
    except (TypeError, ValueError):
        created = 0
    return {"id": str(body.get("id") or ""),
            "created_at": created,
            "previous_response_id": str(body.get("previous_response_id") or ""),
            "conversation": str(conversation or ""),
            "status": str(body.get("status") or "")}


def age_days(created_at, now):
    """Age of one link in days. Pure. The clock is an argument."""
    try:
        created = int(created_at)
        now = int(now)
    except (TypeError, ValueError):
        return None
    if created <= 0:
        return None
    return (now - created) / 86400.0


def oldest_link(chain):
    """The link that decides the chain. Pure. None for an empty chain."""
    usable = [row for row in chain or [] if int(row.get("created_at") or 0) > 0]
    if not usable:
        return None
    return min(usable, key=lambda row: int(row["created_at"]))


def runway_days(chain, now, retention=RETENTION_DAYS):
    """Days left on the oldest link. Pure. None when nothing is datable."""
    row = oldest_link(chain)
    if row is None:
        return None
    age = age_days(row["created_at"], now)
    if age is None:
        return None
    return retention - age


def classify_chain(head, chain, gap, unreadable, truncated, now, warn_days):
    """Grade one walked chain. Pure. Returns (state, detail)."""
    if unreadable:
        return ("chain-unreadable",
                "%s: %s, so nothing about this chain was established"
                % (head, unreadable))
    if gap:
        others = len(chain)
        if others:
            return ("chain-broken",
                    "%s: the parent %s no longer resolves, so the next turn on "
                    "this thread will 404" % (head, gap))
        return ("chain-broken",
                "%s: this id itself does not resolve. It has either aged out of "
                "the 30 day retention or was never stored" % head)
    if not chain:
        return ("nothing-walked", "%s: no links were read" % head)

    conversations = {row.get("conversation") for row in chain}
    if conversations and "" not in conversations:
        return ("conversation-backed",
                "%s: items attached to a conversation are persisted with no 30 "
                "day TTL" % head)

    left = runway_days(chain, now)
    if left is None:
        return ("undatable",
                "%s: no link carried a usable created_at, so the runway cannot "
                "be computed" % head)
    if left <= 0:
        return ("chain-broken",
                "%s: the oldest link is past the documented %d day retention "
                "and is only resolving on borrowed time"
                % (head, RETENTION_DAYS))
    if left <= warn_days:
        row = oldest_link(chain)
        return ("chain-expiring",
                "%s: the oldest link is %.1f days old, so this chain has about "
                "%.1f days of the documented %d day retention left"
                % (head, age_days(row["created_at"], now), left, RETENTION_DAYS))
    if truncated:
        return ("chain-unfinished",
                "%s: stopped at the hop limit before reaching a root, so the "
                "oldest link was never seen" % head)
    return ("chain-intact",
            "%s: walked to a root with %.1f days left on the oldest link"
            % (head, left))


def repair_lines(state):
    """The repair for one verdict. Pure. Printed, never performed."""
    move = ("move this thread onto a conversation object, whose items are "
            "persisted with no 30 day TTL, or keep the full message history in "
            "your own store and replay it.")
    if state == "chain-broken":
        return ["fall back to replaying local history for this thread, and stop "
                "chaining from an id you did not verify.", move]
    if state == "chain-expiring":
        return [move,
                "until then, verify the parent resolves before continuing an "
                "old thread rather than discovering it inside a user request."]
    if state == "chain-unreadable":
        return ["the key could not read this response. Check that it belongs to "
                "the project that created it before concluding anything about "
                "retention."]
    if state == "chain-unfinished":
        return ["raise --max-hops for this thread. A chain graded without "
                "reaching its oldest link has not been graded."]
    if state == "undatable":
        return ["the links resolved but carried no created_at, which is odd "
                "enough to read one of them by hand before trusting the rest."]
    return []


def retrieve(response_id, key, timeout=30):
    """One GET. Returns (status, body). A 404 is the answer, not an error."""
    try:
        r = requests.get("%s/%s" % (BASE_URL, response_id),
                         headers={"Authorization": "Bearer " + key},
                         timeout=timeout)
    except requests.RequestException as exc:
        log.debug("retrieve of %s failed: %s", response_id, exc)
        return (None, None)
    try:
        return (r.status_code, r.json())
    except ValueError:
        return (r.status_code, None)


def walk(head, key, max_hops):
    """Follow one chain upward. Returns (chain, gap, unreadable, truncated)."""
    chain = []
    current = head
    for _ in range(max_hops):
        status, body = retrieve(current, key)
        if status == 404:
            return (chain, current, "", False)
        if status in (401, 403):
            return (chain, "", "HTTP %d reading %s" % (status, current), False)
        if status != 200:
            return (chain, "", "HTTP %s reading %s" % (status, current), False)
        row = link_row(body)
        chain.append(row)
        if not row["previous_response_id"]:
            return (chain, "", "", False)
        current = row["previous_response_id"]
    return (chain, "", "", True)


def main():
    ap = argparse.ArgumentParser(description=__doc__)
    ap.add_argument("--ids", required=True,
                    help="file of response ids, newest per thread, one per line")
    ap.add_argument("--max-hops", type=int, default=20,
                    help="how far up one chain to walk")
    ap.add_argument("--warn-days", type=float, default=5.0,
                    help="days of remaining retention that count as a finding")
    args = ap.parse_args()

    key = os.environ.get("OPENAI_API_KEY")
    if not key:
        log.error("set OPENAI_API_KEY to a project key set to Read Only. Every "
                  "call is a GET of /v1/responses/{response_id}")
        return 2
    try:
        with open(args.ids, "r", encoding="utf-8") as fh:
            heads = parse_ids(fh.read())
    except OSError as exc:
        log.error("could not read %s: %s", args.ids, exc)
        return 2
    if not heads:
        log.error("no response ids in %s. /v1/responses cannot be listed, so "
                  "the chains have to start from ids you recorded", args.ids)
        return 2

    now = int(time.time())
    findings = 0
    for head in heads:
        chain, gap, unreadable, truncated = walk(head, key, args.max_hops)
        row = oldest_link(chain)
        if row:
            age = age_days(row["created_at"], now)
            log.info("%-10s chain of %d, oldest %s, %.1f days old",
                     head, len(chain), row["id"], age or 0.0)
        else:
            log.info("%-10s chain of %d", head, len(chain))

        state, detail = classify_chain(head, chain, gap, unreadable, truncated,
                                       now, args.warn_days)
        emit = log.warning if state in FINDINGS else log.info
        emit("%-20s %s", state, detail)
        for line in repair_lines(state):
            emit("  repair: %s", line)
        if state in FINDINGS:
            findings += 1

    log.info("%d chain(s) walked, %d finding(s)", len(heads), findings)
    return 1 if findings else 0


if __name__ == "__main__":
    sys.exit(main())

/**
 * Walk recorded previous_response_id chains and find the links already gone.
 *
 * Read only. One GET of /v1/responses/{response_id} per link. No completion is
 * created, nothing is stored and nothing is deleted.
 *
 * Response objects are saved for 30 days by default, so a chain is only as
 * durable as its oldest surviving link. A response attached to a conversation
 * has its items persisted with no 30 day TTL, which is the repair.
 *
 * /v1/responses has no list endpoint, so the ids come from your own records.
 */
import { readFile } from 'node:fs/promises';

const BASE_URL = 'https://api.openai.com/v1/responses';

export const RETENTION_DAYS = 30;

const FINDINGS = new Set(['chain-broken', 'chain-expiring', 'chain-unreadable']);

/** Response ids from a file. Pure. Blanks, comments and repeats dropped. */
export function parseIds(text) {
  const seen = [];
  for (const line of String(text ?? '').split('\n')) {
    const item = line.split('#')[0].trim();
    if (item && !seen.includes(item)) seen.push(item);
  }
  return seen;
}

/** One retrieved response, reduced. Pure. Four fields and no invention. */
export function linkRow(body) {
  const row = (body && typeof body === 'object') ? body : {};
  const conversation = (row.conversation && typeof row.conversation === 'object')
    ? row.conversation.id : row.conversation;
  const created = Number(row.created_at ?? 0);
  return {
    id: String(row.id ?? ''),
    created_at: Number.isFinite(created) ? Math.trunc(created) : 0,
    previous_response_id: String(row.previous_response_id ?? ''),
    conversation: String(conversation ?? ''),
    status: String(row.status ?? ''),
  };
}

/** Age of one link in days. Pure. The clock is an argument. */
export function ageDays(createdAt, now) {
  const created = Number(createdAt);
  const at = Number(now);
  if (!Number.isFinite(created) || !Number.isFinite(at) || created <= 0) return null;
  return (at - created) / 86400;
}

/** The link that decides the chain. Pure. Null for an empty chain. */
export function oldestLink(chain) {
  const usable = (chain ?? []).filter((row) => Number(row?.created_at ?? 0) > 0);
  if (!usable.length) return null;
  return usable.reduce((a, b) => (Number(a.created_at) <= Number(b.created_at) ? a : b));
}

/** Days left on the oldest link. Pure. Null when nothing is datable. */
export function runwayDays(chain, now, retention = RETENTION_DAYS) {
  const row = oldestLink(chain);
  if (!row) return null;
  const age = ageDays(row.created_at, now);
  return age === null ? null : retention - age;
}

/** Grade one walked chain. Pure. Returns [state, detail]. */
export function classifyChain(head, chain, gap, unreadable, truncated, now, warnDays) {
  if (unreadable) {
    return ['chain-unreadable',
      `${head}: ${unreadable}, so nothing about this chain was established`];
  }
  if (gap) {
    if ((chain ?? []).length) {
      return ['chain-broken',
        `${head}: the parent ${gap} no longer resolves, so the next turn on this `
        + 'thread will 404'];
    }
    return ['chain-broken',
      `${head}: this id itself does not resolve. It has either aged out of the `
      + '30 day retention or was never stored'];
  }
  if (!(chain ?? []).length) return ['nothing-walked', `${head}: no links were read`];

  const conversations = new Set(chain.map((row) => row.conversation ?? ''));
  if (!conversations.has('')) {
    return ['conversation-backed',
      `${head}: items attached to a conversation are persisted with no 30 day TTL`];
  }

  const left = runwayDays(chain, now);
  if (left === null) {
    return ['undatable',
      `${head}: no link carried a usable created_at, so the runway cannot be computed`];
  }
  if (left <= 0) {
    return ['chain-broken',
      `${head}: the oldest link is past the documented ${RETENTION_DAYS} day `
      + 'retention and is only resolving on borrowed time'];
  }
  if (left <= warnDays) {
    const row = oldestLink(chain);
    return ['chain-expiring',
      `${head}: the oldest link is ${ageDays(row.created_at, now).toFixed(1)} days `
      + `old, so this chain has about ${left.toFixed(1)} days of the documented `
      + `${RETENTION_DAYS} day retention left`];
  }
  if (truncated) {
    return ['chain-unfinished',
      `${head}: stopped at the hop limit before reaching a root, so the oldest `
      + 'link was never seen'];
  }
  return ['chain-intact',
    `${head}: walked to a root with ${left.toFixed(1)} days left on the oldest link`];
}

/** The repair for one verdict. Pure. Printed, never performed. */
export function repairLines(state) {
  const move = 'move this thread onto a conversation object, whose items are '
    + 'persisted with no 30 day TTL, or keep the full message history in your '
    + 'own store and replay it.';
  if (state === 'chain-broken') {
    return ['fall back to replaying local history for this thread, and stop '
      + 'chaining from an id you did not verify.', move];
  }
  if (state === 'chain-expiring') {
    return [move, 'until then, verify the parent resolves before continuing an '
      + 'old thread rather than discovering it inside a user request.'];
  }
  if (state === 'chain-unreadable') {
    return ['the key could not read this response. Check that it belongs to the '
      + 'project that created it before concluding anything about retention.'];
  }
  if (state === 'chain-unfinished') {
    return ['raise --max-hops for this thread. A chain graded without reaching '
      + 'its oldest link has not been graded.'];
  }
  if (state === 'undatable') {
    return ['the links resolved but carried no created_at, which is odd enough '
      + 'to read one of them by hand before trusting the rest.'];
  }
  return [];
}

async function retrieve(responseId, key) {
  try {
    const res = await fetch(`${BASE_URL}/${responseId}`,
      { headers: { Authorization: `Bearer ${key}` } });
    let body = null;
    try { body = await res.json(); } catch { body = null; }
    return [res.status, body];
  } catch {
    return [null, null];
  }
}

async function walk(head, key, maxHops) {
  const chain = [];
  let current = head;
  for (let hop = 0; hop < maxHops; hop += 1) {
    const [status, body] = await retrieve(current, key);
    if (status === 404) return [chain, current, '', false];
    if (status !== 200) return [chain, '', `HTTP ${status} reading ${current}`, false];
    const row = linkRow(body);
    chain.push(row);
    if (!row.previous_response_id) return [chain, '', '', false];
    current = row.previous_response_id;
  }
  return [chain, '', '', true];
}

function args(argv) {
  const out = { maxHops: 20, warnDays: 5 };
  for (let i = 0; i < argv.length; i += 1) {
    if (argv[i] === '--ids') out.ids = argv[i += 1];
    else if (argv[i] === '--max-hops') out.maxHops = Number.parseInt(argv[i += 1], 10);
    else if (argv[i] === '--warn-days') out.warnDays = Number(argv[i += 1]);
  }
  return out;
}

async function main() {
  const opts = args(process.argv.slice(2));
  const key = process.env.OPENAI_API_KEY;
  if (!key) {
    console.error('set OPENAI_API_KEY to a project key set to Read Only. Every '
      + 'call is a GET of /v1/responses/{response_id}');
    process.exitCode = 2;
    return;
  }
  if (!opts.ids) {
    console.error('usage: --ids <file> [--max-hops 20] [--warn-days 5]');
    process.exitCode = 2;
    return;
  }
  let heads;
  try {
    heads = parseIds(await readFile(opts.ids, 'utf8'));
  } catch (err) {
    console.error(`could not read ${opts.ids}: ${err.message}`);
    process.exitCode = 2;
    return;
  }
  if (!heads.length) {
    console.error(`no response ids in ${opts.ids}. /v1/responses cannot be `
      + 'listed, so the chains have to start from ids you recorded');
    process.exitCode = 2;
    return;
  }

  const now = Math.trunc(Date.now() / 1000);
  let findings = 0;
  for (const head of heads) {
    const [chain, gap, unreadable, truncated] = await walk(head, key, opts.maxHops);
    const row = oldestLink(chain);
    if (row) {
      console.log(`${head.padEnd(10)} chain of ${chain.length}, oldest ${row.id}, `
        + `${(ageDays(row.created_at, now) ?? 0).toFixed(1)} days old`);
    } else {
      console.log(`${head.padEnd(10)} chain of ${chain.length}`);
    }
    const [state, detail] = classifyChain(head, chain, gap, unreadable, truncated,
                                          now, opts.warnDays);
    console.log(`${state.padEnd(20)} ${detail}`);
    for (const line of repairLines(state)) console.log(`  repair: ${line}`);
    if (FINDINGS.has(state)) findings += 1;
  }
  console.log(`${heads.length} chain(s) walked, ${findings} finding(s)`);
  process.exitCode = findings ? 1 : 0;
}

if (import.meta.url === `file://${process.argv[1]}`) await main();

from openai_response_chain_probe import (RETENTION_DAYS, age_days,
                                        classify_chain, link_row, oldest_link,
                                        parse_ids, repair_lines, runway_days)

NOW = 1_800_000_000
DAY = 86400


def link(rid, days_old, parent="", conversation=""):
    return link_row({"id": rid, "created_at": NOW - int(days_old * DAY),
                     "previous_response_id": parent,
                     "conversation": ({"id": conversation} if conversation
                                      else None),
                     "status": "completed"})


def test_a_missing_parent_is_the_finding_and_names_the_next_turn():
    chain = [link("resp_c9", 1.0, parent="resp_a1")]
    state, detail = classify_chain("resp_c9", chain, "resp_a1", "", False,
                                   NOW, 5.0)
    assert state == "chain-broken"
    assert "resp_a1 no longer resolves" in detail
    assert "next turn on this thread will 404" in detail
    lines = repair_lines(state)
    assert any("replaying local history" in line for line in lines)
    assert any("no 30 day TTL" in line for line in lines)

    # The head itself missing is the same verdict with a different sentence,
    # because a 404 there has two causes and the script names both.
    state, detail = classify_chain("resp_c9", [], "resp_c9", "", False, NOW, 5.0)
    assert state == "chain-broken"
    assert "aged out" in detail and "never stored" in detail


def test_the_runway_comes_from_the_oldest_link_and_not_the_newest():
    chain = [link("resp_f2", 0.5, parent="resp_e1"),
             link("resp_e1", 12.0, parent="resp_d7"),
             link("resp_d7", 26.4)]
    assert oldest_link(chain)["id"] == "resp_d7"
    assert abs(runway_days(chain, NOW) - (RETENTION_DAYS - 26.4)) < 0.01
    state, detail = classify_chain("resp_f2", chain, "", "", False, NOW, 5.0)
    assert state == "chain-expiring"
    assert "26.4 days old" in detail and "3.6 days" in detail
    # Read from the newest link this chain looks like it has 29.5 days left.
    assert age_days(chain[0]["created_at"], NOW) < 1.0


def test_a_conversation_backed_chain_is_not_this_note():
    chain = [link("resp_k4", 1.0, parent="resp_k3", conversation="conv_x1"),
             link("resp_k3", 44.0, conversation="conv_x1")]
    state, detail = classify_chain("resp_k4", chain, "", "", False, NOW, 5.0)
    assert state == "conversation-backed"
    assert "no 30 day TTL" in detail
    assert repair_lines(state) == []
    # One link without a conversation is not a conversation backed chain.
    mixed = [chain[0], link("resp_k3", 44.0)]
    assert classify_chain("resp_k4", mixed, "", "", False, NOW, 5.0)[0] \
        == "chain-broken"


def test_a_chain_cut_short_by_the_hop_limit_is_not_graded_healthy():
    chain = [link("resp_z9", 1.0, parent="resp_z8"),
             link("resp_z8", 2.0, parent="resp_z7")]
    state, detail = classify_chain("resp_z9", chain, "", "", True, NOW, 5.0)
    assert state == "chain-unfinished"
    assert "oldest link was never seen" in detail
    assert any("--max-hops" in line for line in repair_lines(state))
    # The same chain walked to a root is intact.
    rooted = [chain[0], link("resp_z8", 2.0)]
    assert classify_chain("resp_z9", rooted, "", "", False, NOW, 5.0)[0] \
        == "chain-intact"


def test_link_row_reads_four_fields_and_invents_no_store_flag():
    row = link_row({"id": "resp_a1", "created_at": 1700000000,
                    "previous_response_id": None,
                    "conversation": {"id": "conv_x1"}, "status": "completed"})
    assert row == {"id": "resp_a1", "created_at": 1700000000,
                   "previous_response_id": "", "conversation": "conv_x1",
                   "status": "completed"}
    assert "store" not in row and "stored" not in row
    assert link_row(None)["id"] == ""
    assert link_row({"created_at": "nonsense"})["created_at"] == 0
    assert age_days(0, NOW) is None and runway_days([], NOW) is None


def test_the_id_file_is_read_the_way_it_is_actually_exported():
    ids = parse_ids("resp_a1\n\n# heads exported 2026-08-30\nresp_b2  # oldest\n"
                    "resp_a1\n   \nresp_c3\n")
    assert ids == ["resp_a1", "resp_b2", "resp_c3"]
    assert parse_ids("") == [] and parse_ids(None) == []
    state, detail = classify_chain("resp_a1", [], "", "HTTP 403 reading resp_a1",
                                   False, NOW, 5.0)
    assert state == "chain-unreadable"
    assert "nothing about this chain was established" in detail

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { RETENTION_DAYS, ageDays, classifyChain, linkRow, oldestLink, parseIds,
         repairLines, runwayDays } from './openai-response-chain-probe.mjs';

const NOW = 1_800_000_000;
const DAY = 86400;

const link = (id, daysOld, parent = '', conversation = '') => linkRow({
  id,
  created_at: NOW - Math.trunc(daysOld * DAY),
  previous_response_id: parent,
  conversation: conversation ? { id: conversation } : null,
  status: 'completed',
});

test('a missing parent is the finding and names the next turn', () => {
  const chain = [link('resp_c9', 1, 'resp_a1')];
  const [state, detail] = classifyChain('resp_c9', chain, 'resp_a1', '', false, NOW, 5);
  assert.equal(state, 'chain-broken');
  assert.ok(detail.includes('resp_a1 no longer resolves'));
  assert.ok(detail.includes('next turn on this thread will 404'));
  const lines = repairLines(state);
  assert.ok(lines.some((l) => l.includes('replaying local history')));
  assert.ok(lines.some((l) => l.includes('no 30 day TTL')));

  const [headState, headDetail] = classifyChain('resp_c9', [], 'resp_c9', '', false, NOW, 5);
  assert.equal(headState, 'chain-broken');
  assert.ok(headDetail.includes('aged out') && headDetail.includes('never stored'));
});

test('the runway comes from the oldest link and not the newest', () => {
  const chain = [link('resp_f2', 0.5, 'resp_e1'),
                 link('resp_e1', 12, 'resp_d7'),
                 link('resp_d7', 26.4)];
  assert.equal(oldestLink(chain).id, 'resp_d7');
  assert.ok(Math.abs(runwayDays(chain, NOW) - (RETENTION_DAYS - 26.4)) < 0.01);
  const [state, detail] = classifyChain('resp_f2', chain, '', '', false, NOW, 5);
  assert.equal(state, 'chain-expiring');
  assert.ok(detail.includes('26.4 days old') && detail.includes('3.6 days'));
  assert.ok(ageDays(chain[0].created_at, NOW) < 1);
});

test('a conversation backed chain is not this note', () => {
  const chain = [link('resp_k4', 1, 'resp_k3', 'conv_x1'),
                 link('resp_k3', 44, '', 'conv_x1')];
  const [state, detail] = classifyChain('resp_k4', chain, '', '', false, NOW, 5);
  assert.equal(state, 'conversation-backed');
  assert.ok(detail.includes('no 30 day TTL'));
  assert.deepEqual(repairLines(state), []);
  const mixed = [chain[0], link('resp_k3', 44)];
  assert.equal(classifyChain('resp_k4', mixed, '', '', false, NOW, 5)[0], 'chain-broken');
});

test('a chain cut short by the hop limit is not graded healthy', () => {
  const chain = [link('resp_z9', 1, 'resp_z8'), link('resp_z8', 2, 'resp_z7')];
  const [state, detail] = classifyChain('resp_z9', chain, '', '', true, NOW, 5);
  assert.equal(state, 'chain-unfinished');
  assert.ok(detail.includes('oldest link was never seen'));
  assert.ok(repairLines(state).some((l) => l.includes('--max-hops')));
  const rooted = [chain[0], link('resp_z8', 2)];
  assert.equal(classifyChain('resp_z9', rooted, '', '', false, NOW, 5)[0], 'chain-intact');
});

test('linkRow reads four fields and invents no store flag', () => {
  const row = linkRow({ id: 'resp_a1', created_at: 1700000000,
                        previous_response_id: null,
                        conversation: { id: 'conv_x1' }, status: 'completed' });
  assert.deepEqual(row, { id: 'resp_a1', created_at: 1700000000,
                          previous_response_id: '', conversation: 'conv_x1',
                          status: 'completed' });
  assert.ok(!('store' in row) && !('stored' in row));
  assert.equal(linkRow(null).id, '');
  assert.equal(linkRow({ created_at: 'nonsense' }).created_at, 0);
  assert.equal(ageDays(0, NOW), null);
  assert.equal(runwayDays([], NOW), null);
});

test('the id file is read the way it is actually exported', () => {
  const ids = parseIds('resp_a1\n\n# heads exported 2026-08-30\nresp_b2  # oldest\n'
    + 'resp_a1\n   \nresp_c3\n');
  assert.deepEqual(ids, ['resp_a1', 'resp_b2', 'resp_c3']);
  assert.deepEqual(parseIds(''), []);
  assert.deepEqual(parseIds(null), []);
  const [state, detail] = classifyChain('resp_a1', [], '', 'HTTP 403 reading resp_a1',
                                        false, NOW, 5);
  assert.equal(state, 'chain-unreadable');
  assert.ok(detail.includes('nothing about this chain was established'));
});