import { createReadStream } from 'node:fs';

import { createInterface } from 'node:readline';

import { truncate } from './util.js';

import { TreetraceError, ExitCode } from './util.js';

const DAG_TYPES = new Set(['user', 'assistant', 'system', 'attachment']);

const USER_DECLINED_TOOL_RE =

  /\bthe user (?:doesn'?t|does not|didn'?t|did not) want to proceed with this tool use\b|\bthe user (?:wants?|wanted) (?:you|me|the agent) to\b|\buser (?:rejected|declined|cancelled|canceled) (?:this|the) tool(?: use)?\b|\buser chose to reject\b/i;

const PERMISSION_DENIED_RE =

  /\bpermission denied\b|\boperation not permitted\b|\bEACCES\b|\bEPERM\b|\bcommand not found\b|\bOperation cancelled\b|\baccess is denied\b|\brequires? elevation\b/i;

const REFUSAL_TEXT_RE =

  /\b(?:i (?:can(?:'|no)t|am (?:unable|not able|not permitted) to|won['']?t|cannot|do not|don['']?t (?:think i (?:should|can)|feel comfortable)|'?m not (?:able|allowed|going) to)|(?:sorry|apolog(?:y|ies|ize))[,.]? i (?:can(?:'|no)t|am unable|won['']?t|cannot)|as (?:an? )?(?:ai|language model|assistant)[, ]+(?:i |we )?(?:can(?:'|no)t|cannot|am unable|won['']?t)|i'?m programmed (?:to decline|not to)|against my (?:guidelines|policies|programming))\b/i;

const USER_TEXT_DECLINE_RE =

  /^(?:no(?:pe)?\s*[,.)]?\s+|stop\s*[,.)]?\s+|cancel\s*[,.)]?\s+|don'?t\s+|do not\s+|don'?t do (?:that|this|it)\b|stop (?:that|this|it|doing)\b|scrap (?:that|this|it|the)\b|revert\b|undo\b|roll\s?back\b|rip (?:that|this|it|the)\b|back (?:it|that|this) out\b|take (?:it|that|this) out\b|that'?s not it\b|that is not it\b|not that one\b|not quite\b|scratch that\b|nevermind\b|never mind\b)/i;

const DECLINE_INTERJECTION_RE =

  /^(?:(?:whoa|wait|hold on|hold up|hold the phone|hmm+|ugh+|argh+|actually|no wait|ok wait|wait wait|yikes)[\s,!.:;-]+)+/i;

const IMPERATIVE_REVERSAL_RE =

  /\b(?:stop|undo|revert|yank|rip|kill|scrap|nix|roll\s?back|back(?:\s+(?:it|that|this))?\s+out|take(?:\s+(?:it|that|this))?\s+out)\b/i;

const BARE_STOP_RE =

  /^(?:stop|undo|revert|yank|nix|scrap|rip|kill|roll\s?back)\s*(?:it|that|this|the\b[^.]*)?[.!,;:\s]*$/i;

const BACKREF_DEMONSTRATIVE_RE = /\b(?:that|this|those|these|it)\b/i;

const BENIGN_DECLINE_OPENER_RE =

  /^(?:no\s+(?:problem|worries|worry|rush|need|thanks|biggie|prob(?:lem)?s?|issue)\b|nope?\s+(?:problem|worries)\b|don'?t\s+(?:forget|hesitate|worry|bother|stop)\b|stop\s+(?:being|saying|telling|apologi[sz]|with the|the apolog))/i;

const COMPLIANT_WONT_RE =

  /\bi\s+(?:won['']?t|will not|promise not to)\s+(?:touch|change|modify|alter|edit|delete|remove|drop|break|add|introduce|expose|leak|hardcode|hard-code|commit|push|overwrite|override|re-?add|reintroduce)\b/i;

const HARD_REFUSAL_RE =

  /\bi\s+can(?:'|no)?t\b|\b(?:am|'?m)\s+(?:unable|not able|not permitted|not allowed)\b|\bagainst my (?:guidelines|policies|programming)\b|\bas an? (?:ai|language model|assistant)\b/i;

function classifyToolResultRejection(content) {

  const text = typeof content === 'string' ? content : '';

  if (!text) return { kind: 'tool_execution_error', confidence: 0.85, evidence: null };

  if (USER_DECLINED_TOOL_RE.test(text)) {

    return { kind: 'user_declined_tool', confidence: 1.0, evidence: truncate(text, 160) };

  }

  if (PERMISSION_DENIED_RE.test(text)) {

    return { kind: 'permission_denied', confidence: 0.85, evidence: truncate(text, 160) };

  }

  return { kind: 'tool_execution_error', confidence: 0.9, evidence: truncate(text, 160) };

}

export function looksLikeRefusal(text) {

  if (typeof text !== 'string' || text.length > 4000) return false;

  if (COMPLIANT_WONT_RE.test(text) && !HARD_REFUSAL_RE.test(text)) return false;

  return REFUSAL_TEXT_RE.test(text);

}

const NOVEL_REFUSAL_RE =

  /\bi(?:'|’)?m\s+going\s+to\s+decline\b|\bi(?:'|’)?ll\s+decline\b|\bi\s+decline\s+(?:this|that|to)\b|\bi(?:'|’)?d\s+rather\s+not\b|\bi(?:'|’)?m\s+not\s+(?:comfortable|willing|going)\s+to?\b|\bthat(?:'|’)?s\s+not\s+something\s+i(?:'|’)?(?:ll|m)?\s*(?:can|will|would|want|going)\b|\bnot\s+something\s+i\s+can\s+help\s+with\b|\bcrosses\s+a\s+line\s+i\s+won(?:'|’)?t\s+cross\b|\bi(?:'|’)?m\s+not\s+going\s+to\s+(?:do|build|implement|write|add)\b/i;

function looksLikeRefusalStructural(text) {

  if (typeof text !== 'string' || text.length > 4000) return false;

  if (COMPLIANT_WONT_RE.test(text) && !HARD_REFUSAL_RE.test(text)) return false;

  return REFUSAL_TEXT_RE.test(text) || NOVEL_REFUSAL_RE.test(text);

}

function looksLikeUserTextDecline(text) {

  let t = typeof text === 'string' ? text.trim() : '';

  if (!t || t.length > 240) return false;

  t = t.replace(DECLINE_INTERJECTION_RE, '').trim();

  if (BENIGN_DECLINE_OPENER_RE.test(t)) return false;

  return USER_TEXT_DECLINE_RE.test(t);

}

function backRefsPriorAssistant(clause, priorAssistant) {

  if (BACKREF_DEMONSTRATIVE_RE.test(clause)) return true;

  if (priorAssistant && priorAssistant.tokens && priorAssistant.tokens.size) {

    const low = clause.toLowerCase();

    for (const tok of priorAssistant.tokens) {

      if (tok.length >= 4 && low.includes(tok)) return true;

    }

  }

  return false;

}

const DESTRUCTIVE_ATTR_RE =

  /\byou\b[^.!?;]{0,40}\b(?:blew\s+away|blow\s+away|nuked?|wiped?|truncated?|dropped?|deleted?|destroyed?|clobbered?|ripped?\s+(?:out|away))\b|\b(?:that|this|the)\b[^.!?;]{0,30}\b(?:drop[\s-]?and[\s-]?recreate[d]?|blew\s+away|truncated?|wiped?)\b/i;

const DESTRUCTIVE_REDIRECT_CUE_RE =

  /\bnon[\s-]?destructive\b|\badditive\b|\binstead\b|\bstop\b|\bdon'?t\b[^.!?;]{0,30}\b(?:drop|truncate|wipe|recreate|delete|blow)\b|\bnever\b[^.!?;]{0,30}\b(?:drop|truncate|wipe|recreate|delete)\b|\bmake\b[^.!?;]{0,30}\b(?:migration|change|it)\b[^.!?;]{0,20}\b(?:additive|non[\s-]?destructive|safe)\b/i;

function looksLikeStructuralDecline(text, priorAssistant) {

  let t = typeof text === 'string' ? text.trim() : '';

  if (!t || t.length > 240) return false;

  t = t.replace(DECLINE_INTERJECTION_RE, '').trim();

  if (BENIGN_DECLINE_OPENER_RE.test(t)) return false;

  const clauses = t.split(/[.!?;\n]/);

  for (const rawClause of clauses) {

    const clause = rawClause.trim();

    if (!clause) continue;

    const m = clause.match(IMPERATIVE_REVERSAL_RE);

    if (!m) continue;

    const idx = clause.toLowerCase().indexOf(m[0].toLowerCase());

    const lead = clause.slice(0, idx).replace(/[,\s]+$/, '').trim();

    if (lead && !/^(?:no|nope|ok|okay|please|hey|and|so|then|wait|hold on|also)\b[\s,]*$/i.test(lead)) {

      continue;

    }

    if (BARE_STOP_RE.test(clause)) return true;

    if (backRefsPriorAssistant(clause.slice(idx), priorAssistant)) return true;

  }

  if (

    DESTRUCTIVE_ATTR_RE.test(t) &&

    DESTRUCTIVE_REDIRECT_CUE_RE.test(t) &&

    backRefsPriorAssistant(t, priorAssistant)

  ) {

    return true;

  }

  return false;

}

const STRUCT_REDIRECT_STOPTOKENS = new Set([

  'with', 'into', 'just', 'back', 'goal', 'under', 'over', 'this', 'that', 'these', 'those',

  'then', 'than', 'them', 'they', 'your', 'have', 'will', 'from', 'about', 'across', 'after',

  'approach', 'instead', 'reverting', 'switching', 'collapsing', 'understood', 'reorienting',

  'misread', 'deleting', 'returning', 'added', 'done', 'made', 'built', 'rebuilt', 'using',

  'thanks', 'later', 'minimize', 'maximize', 'target', 'budget', 'local', 'bench',

]);

const NEGATED_RESTATEMENT_RE =

  /,\s*not\b|\b(?:wanted|want|cared|care|asked|meant|need|needed|expected|after)\b[^.]{0,40}\bnot\b|\bnot\b[^.]{0,30}\b(?:but|instead)\b/i;

const GOAL_MISMATCH_SELF_RE =

  /\byou\s+(?:solved|built|did|made|gave|chose|used|wrote|created|went|took|picked|implemented|optimi[sz]ed|focused|targeted)\b[^.]{0,40}\bwrong\b/i;

const GOAL_MISMATCH_RE =

  /\bwrong\s+(?:problem|thing|goal|approach|direction|track|path|idea|feature|task|tool|one|axis|shape)\b/i;

const STRUCT_REVERSAL_RE =

  /\b(?:nix|scrap|revert|undo|yank)\b|\b(?:rip|tear|take|strip|pull|gut)\b[^.]{0,30}\bout\b/i;

const PERMISSIVE_FRAMING_RE =

  /\b(?:feel free to|go ahead and|go ahead|you (?:can|could|may|might)|if you (?:want|like|prefer)|whenever you|happy for you to|fine to)\b/i;

const SCOPE_AFFIRMATION_RE =

  /\bi (?:just|only) (?:want|need|wanted|needed)\b|\bthat'?s all\b|\bjust (?:want|keep) (?:it|that)\b/i;

function looksLikeStructuralRedirect(text, priorAssistant) {

  let t = typeof text === 'string' ? text.trim() : '';

  if (!t || t.length > 600) return false;

  if (!priorAssistant || !priorAssistant.tokens || !priorAssistant.tokens.size) return false;

  t = t.replace(DECLINE_INTERJECTION_RE, '').trim();

  if (BENIGN_DECLINE_OPENER_RE.test(t)) return false;

  if (PERMISSIVE_FRAMING_RE.test(t) || SCOPE_AFFIRMATION_RE.test(t)) return false;

  if (GOAL_MISMATCH_SELF_RE.test(t)) return true;

  const hasCue =

    NEGATED_RESTATEMENT_RE.test(t) || GOAL_MISMATCH_RE.test(t) || STRUCT_REVERSAL_RE.test(t);

  if (!hasCue) return false;

  const low = t.toLowerCase();

  for (const tok of priorAssistant.tokens) {

    if (tok.length < 4 || STRUCT_REDIRECT_STOPTOKENS.has(tok)) continue;

    if (new RegExp(`\\b${tok.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`).test(low)) return true;

  }

  return false;

}

function structuralRedirectIsDecline(text, priorAssistant) {

  let t = typeof text === 'string' ? text.trim() : '';

  if (!t || t.length > 600) return false;

  if (!priorAssistant || !priorAssistant.tokens || !priorAssistant.tokens.size) return false;

  t = t.replace(DECLINE_INTERJECTION_RE, '').trim();

  if (BENIGN_DECLINE_OPENER_RE.test(t)) return false;

  if (PERMISSIVE_FRAMING_RE.test(t)) return false;

  if (!STRUCT_REVERSAL_RE.test(t)) return false;

  const low = t.toLowerCase();

  for (const tok of priorAssistant.tokens) {

    if (tok.length < 4 || STRUCT_REDIRECT_STOPTOKENS.has(tok)) continue;

    if (new RegExp(`\\b${tok.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`).test(low)) return true;

  }

  return false;

}

const GOAL_MISMATCH_FRAME_RE =

  /\bthat'?s not what i (?:asked|wanted|meant|said|requested)\b|\bthe whole point (?:is|was|of)\b|\bwhat i (?:actually|really) (?:wanted|asked|meant|need(?:ed)?)\b|\bmissed the (?:point|goal)\b|\bnot what i'?m after\b/i;

const ROOT_GOAL_STOPTOKENS = new Set([

  'support', 'update', 'updates', 'feature', 'features', 'system', 'systems', 'please', 'should',

  'would', 'could', 'about', 'these', 'those', 'their', 'there', 'which', 'while', 'where', 'thing',

  'things', 'something', 'devices', 'device', 'images', 'image', 'field', 'pull', 'make', 'build',

  'built', 'using', 'with', 'from', 'into', 'over', 'they', 'them', 'this', 'that', 'have', 'need',

  'needs', 'want', 'wants', 'when', 'then', 'than', 'your', 'each', 'able', 'code', 'work', 'works',

]);

function extractRootGoalTokens(text) {

  const out = new Set();

  const low = String(text || '').toLowerCase();

  for (const w of low.match(/[a-z][a-z0-9_-]{3,}/g) || []) {

    if (w.length >= 4 && !ROOT_GOAL_STOPTOKENS.has(w)) out.add(w);

  }

  for (const phrase of low.match(/[a-z]{2,}(?:-[a-z]{2,}){1,}/g) || []) {

    if (phrase.length >= 6) out.add(phrase);

  }

  return out;

}

function looksLikeGoalMismatchRedirect(text, rootGoalTokens) {

  let t = typeof text === 'string' ? text.trim() : '';

  if (!t || t.length > 600) return false;

  if (!rootGoalTokens || !rootGoalTokens.size) return false;

  if (!GOAL_MISMATCH_FRAME_RE.test(t)) return false;

  const low = t.toLowerCase();

  for (const tok of rootGoalTokens) {

    if (tok.length < 4) continue;

    if (new RegExp(`\\b${tok.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`).test(low)) return true;

  }

  return false;

}

function buildPriorAssistantSnapshot(files, narration) {

  const tokens = new Set();

  for (const f of files) {

    const base = String(f).split(/[\\/]/).pop();

    if (base && base.length >= 4) tokens.add(base.toLowerCase());

    for (const seg of String(f).toLowerCase().split(/[\\/.+_-]+/)) {

      if (seg.length >= 4) tokens.add(seg);

    }

  }

  for (const w of String(narration || '').toLowerCase().match(/[a-z][a-z0-9_-]{3,}/g) || []) {

    tokens.add(w);

  }

  return { tokens };

}

export async function parseSessionFile(path, sessionMeta = {}) {

  const session = {

    sessionId: sessionMeta.sessionId || null,

    path,

    title: null,

    customTitle: null,

    version: null,

    cwd: null,

    gitBranch: null,

    firstTs: null,

    lastTs: null,

    prompts: [],

    index: new Map(),

    leafUuid: null,

    activeLeafUuid: null,

    stats: {

      userLines: 0,

      assistantLines: 0,

      toolUses: 0,

      models: new Set(),

      filesTouched: new Set(),

      inputTokens: 0,

      outputTokens: 0,

      interruptions: 0,

      rejections: 0,

      rejectionsByKind: Object.create(null),

    },

    isContinuation: false,

    _usageByMsgId: new Map(),

    _pendingInterruption: false,

    _currentPrompt: null,

    _priorAssistant: null,

    _rootGoalTokens: null,

  };

  const stream = createReadStream(path, { encoding: 'utf8' });

  const rl = createInterface({ input: stream, crlfDelay: Infinity });

  for await (const line of rl) {

    if (!line || line.charCodeAt(0) !== 123 ) continue;

    let rec;

    try {

      rec = JSON.parse(line);

    } catch {

      continue;

    }

    try {

      ingestRecord(session, rec);

    } catch {

      continue;

    }

  }

  rl.close();

  for (const usage of session._usageByMsgId.values()) {

    session.stats.inputTokens += usage.input_tokens || 0;

    session.stats.outputTokens += usage.output_tokens || 0;

  }

  session._usageByMsgId = null;

  if (session.customTitle) session.title = session.customTitle;

  session.stats.models = [...session.stats.models];

  session.stats.filesTouched = [...session.stats.filesTouched];

  session.stats.rejectionsByKind = { ...session.stats.rejectionsByKind };

  return session;

}

function ingestRecord(session, rec) {

  switch (rec.type) {

    case 'user':

      ingestUser(session, rec);

      break;

    case 'assistant':

      ingestAssistant(session, rec);

      break;

    case 'system':

      indexDagNode(session, rec, {

        parentOverride:

          rec.subtype === 'compact_boundary' && rec.logicalParentUuid

            ? rec.logicalParentUuid

            : undefined,

      });

      break;

    case 'attachment':

      indexDagNode(session, rec);

      break;

    case 'summary':

      if (rec.summary && !session.title) session.title = rec.summary;

      break;

    case 'ai-title':

      if (rec.aiTitle || rec.title) session.title = rec.aiTitle || rec.title;

      break;

    case 'custom-title':

      if (rec.customTitle) session.customTitle = rec.customTitle;

      break;

    case 'last-prompt':

      if (rec.leafUuid) session.activeLeafUuid = rec.leafUuid;

      break;

    default:

      break;

  }

  if (!session.sessionId && rec.sessionId) session.sessionId = rec.sessionId;

  if (!session.version && rec.version) session.version = rec.version;

  if (!session.cwd && rec.cwd) session.cwd = rec.cwd;

  if (!session.gitBranch && rec.gitBranch) session.gitBranch = rec.gitBranch;

  if (rec.timestamp && DAG_TYPES.has(rec.type)) {

    if (!session.firstTs) session.firstTs = rec.timestamp;

    session.lastTs = rec.timestamp;

  }

}

function indexDagNode(session, rec, { parentOverride } = {}) {

  if (!rec.uuid) return;

  session.index.set(rec.uuid, {

    parentUuid: parentOverride !== undefined ? parentOverride : rec.parentUuid || null,

    type: rec.type,

    ts: rec.timestamp || null,

  });

  if (!rec.isSidechain) session.leafUuid = rec.uuid;

}

function attachRejection(session, rejection) {

  if (!rejection || typeof rejection.kind !== 'string') return;

  let prompt = session._currentPrompt;

  if (!prompt) {

    prompt = {

      uuid: null,

      parentUuid: session.leafUuid || null,

      ts: rejection.ts || null,

      text: '',

      hasImage: false,

      hadToolResultContext: true,

      afterInterruption: false,

      actions: [],

      thinking: 0,

      rejections: [],

      isRejectionOnly: true,

    };

    session.prompts.push(prompt);

    session._currentPrompt = prompt;

  }

  if (!Array.isArray(prompt.rejections)) prompt.rejections = [];

  prompt.rejections.push(rejection);

  session.stats.rejections = (session.stats.rejections || 0) + 1;

  session.stats.rejectionsByKind = session.stats.rejectionsByKind || Object.create(null);

  session.stats.rejectionsByKind[rejection.kind] = (session.stats.rejectionsByKind[rejection.kind] || 0) + 1;

}

function ingestUser(session, rec) {

  if (rec.isSidechain || rec.agentId) return;

  indexDagNode(session, rec);

  session.stats.userLines++;

  if (rec.toolUseResult !== undefined || rec.sourceToolAssistantUUID !== undefined) return;

  if (rec.isMeta) return;

  if (rec.isCompactSummary) {

    session.isContinuation = true;

    return;

  }

  if (rec.promptSource === 'system' || rec.promptSource === 'sdk') return;

  if (rec.origin && rec.origin.kind === 'task-notification') return;

  const msg = rec.message || {};

  const { text, hasImage, hasToolResult, hasOnlyToolResult, toolResults } = flattenUserContent(msg.content);

  if (hasOnlyToolResult) {

    for (const tr of toolResults) {

      if (tr && tr.isError) {

        const cls = classifyToolResultRejection(tr.content);

        attachRejection(session, {

          kind: cls.kind,

          source: 'tool_result',

          confidence: cls.confidence,

          toolUseId: tr.toolUseId || null,

          tool: null,

          ts: rec.timestamp || null,

          evidence: cls.evidence,

        });

      }

    }

    return;

  }

  if (hasToolResult && Array.isArray(toolResults)) {

    for (const tr of toolResults) {

      if (tr && tr.isError) {

        const cls = classifyToolResultRejection(tr.content);

        attachRejection(session, {

          kind: cls.kind,

          source: 'tool_result',

          confidence: cls.confidence,

          toolUseId: tr.toolUseId || null,

          tool: null,

          ts: rec.timestamp || null,

          evidence: cls.evidence,

        });

      }

    }

  }

  let trimmed = (text || '').trim();

  if (/^\[Request interrupted by user/i.test(trimmed)) {

    session.stats.interruptions++;

    session._pendingInterruption = true;

    attachRejection(session, {

      kind: 'user_interrupt',

      source: 'text',

      confidence: 1.0,

      toolUseId: null,

      tool: null,

      ts: rec.timestamp || null,

      evidence: truncate(trimmed, 160) || '[Request interrupted by user]',

    });

    return;

  }

  const classification = classifySpecialUserText(trimmed);

  if (classification === 'meta') {

    const recovered = stripWrapperMeta(trimmed);

    if (!recovered || recovered === trimmed) return;

    trimmed = recovered;

  }

  if (classification === 'compact-continuation') {

    session.isContinuation = true;

    return;

  }

  if (classification === 'command') {

    const invocation = extractCommandInvocation(trimmed);

    if (!invocation) return;

    trimmed = invocation;

  }

  if (!trimmed && hasImage) trimmed = '[image-only prompt: screenshot/annotated feedback]';

  if (!trimmed) return;

  if (session._rootGoalTokens === null && !session.isContinuation) {

    session._rootGoalTokens = extractRootGoalTokens(trimmed);

  }

  const isGoalMismatchRedirect = looksLikeGoalMismatchRedirect(trimmed, session._rootGoalTokens);

  const isStructDecline = looksLikeStructuralDecline(trimmed, session._priorAssistant);

  const isStructRedirect =

    looksLikeStructuralRedirect(trimmed, session._priorAssistant) ||

    isGoalMismatchRedirect ||

    isStructDecline;

  if (

    looksLikeUserTextDecline(trimmed) ||

    isStructDecline ||

    structuralRedirectIsDecline(trimmed, session._priorAssistant) ||

    isGoalMismatchRedirect

  ) {

    attachRejectionToText(session, rec, trimmed, 'user_text_decline', 'text', 0.8, isStructRedirect);

    session._pendingInterruption = false;

    return;

  }

  const prompt = {

    uuid: rec.uuid || null,

    parentUuid: rec.parentUuid || null,

    ts: rec.timestamp || null,

    text: trimmed,

    hasImage,

    hadToolResultContext: hasToolResult,

    afterInterruption: Boolean(session._pendingInterruption),

    actions: [],

    thinking: 0,

    rejections: [],

    structuralRedirect: looksLikeStructuralRedirect(trimmed, session._priorAssistant),

    _priorTokens: session._priorAssistant,

  };

  session.prompts.push(prompt);

  session._currentPrompt = prompt;

  session._pendingInterruption = false;

}

function attachRejectionToText(session, rec, text, kind, source, confidence, structuralRedirect = false) {

  const placeholder = {

    uuid: rec.uuid || null,

    parentUuid: rec.parentUuid || null,

    ts: rec.timestamp || null,

    text,

    hasImage: false,

    hadToolResultContext: false,

    afterInterruption: Boolean(session._pendingInterruption),

    actions: [],

    thinking: 0,

    rejections: [],

    structuralRedirect,

    _priorTokens: session._priorAssistant,

  };

  session.prompts.push(placeholder);

  session._currentPrompt = placeholder;

  attachRejection(session, {

    kind,

    source,

    confidence,

    toolUseId: null,

    tool: null,

    ts: rec.timestamp || null,

    evidence: truncate(text, 160),

  });

}

function ingestAssistant(session, rec) {

  if (rec.isSidechain || rec.agentId) return;

  indexDagNode(session, rec);

  session.stats.assistantLines++;

  const msg = rec.message || {};

  const synthetic = msg.model === '<synthetic>' || rec.isApiErrorMessage;

  if (msg.model && !synthetic) session.stats.models.add(msg.model);

  if (msg.usage && !synthetic && (msg.usage.input_tokens || msg.usage.output_tokens)) {

    session._usageByMsgId.set(msg.id || rec.uuid, msg.usage);

  }

  const current = session._currentPrompt;

  const content = Array.isArray(msg.content) ? msg.content : [];

  let narration = '';

  const touchedFiles = new Set();

  for (const block of content) {

    if (block && block.type === 'text' && typeof block.text === 'string') {

      narration += (narration ? ' ' : '') + block.text;

    }

  }

  let refusalClause = null;

  let toolUsesThisTurn = 0;

  for (const block of content) {

    if (!block) continue;

    if (block.type === 'text') {

      if (refusalClause === null && looksLikeRefusalStructural(block.text)) {

        refusalClause = typeof block.text === 'string' ? block.text : '';

      }

    } else if (block.type === 'tool_use') {

      toolUsesThisTurn++;

      session.stats.toolUses++;

      const input = block.input || {};

      const file = input.file_path || input.notebook_path || null;

      if (typeof file === 'string') {

        session.stats.filesTouched.add(file);

        touchedFiles.add(file);

      }

      if (block.name === 'Bash' && typeof input.command === 'string') {

        for (const p of shellFilePaths(input.command)) {

          session.stats.filesTouched.add(p);

          touchedFiles.add(p);

        }

      }

      if (current) {

        current.actions.push({

          tool: block.name || null,

          file: typeof file === 'string' ? file : null,

          command: block.name === 'Bash' && typeof input.command === 'string' ? input.command : null,

          input: summarizeToolInput(block.name, input),

          narration: narration || null,

          model: synthetic ? null : msg.model || null,

        });

      }

    } else if (block.type === 'thinking' || block.type === 'redacted_thinking') {

      if (current) current.thinking++;

    }

  }

  if (refusalClause !== null && toolUsesThisTurn === 0 && msg.stop_reason !== 'refusal') {

    attachRejection(session, {

      kind: 'model_refusal',

      source: 'text_heuristic',

      confidence: 0.7,

      toolUseId: null,

      tool: null,

      ts: rec.timestamp || null,

      evidence: truncate(refusalClause, 160),

    });

  }

  if (msg.stop_reason === 'refusal') {

    attachRejection(session, {

      kind: 'model_refusal',

      source: 'stop_reason',

      confidence: 0.95,

      toolUseId: null,

      tool: null,

      ts: rec.timestamp || null,

      evidence: null,

    });

  }

  if (touchedFiles.size || narration) {

    session._priorAssistant = buildPriorAssistantSnapshot(touchedFiles, narration);

  }

}

const SHELL_PATH_RE = /(?:^|(?<=\s|[=,;|&`()]))(\$\{[^}]*\}|\$[A-Za-z_][A-Za-z0-9_]*|(\.{0,2}\/[^\s'"\\,;|&`()\[\]{}<>$!?*#]+))/g;

function shellFilePaths(cmd) {

  if (typeof cmd !== 'string' || !cmd) return [];

  const seen = new Set();

  const out = [];

  for (const m of cmd.matchAll(SHELL_PATH_RE)) {

    const tok = m[2];

    if (!tok) continue;

    const cleaned = tok.replace(/['">]+$/, '');

    if (!cleaned || cleaned.endsWith('/') || seen.has(cleaned)) continue;

    seen.add(cleaned);

    out.push(cleaned);

  }

  return out;

}

const INPUT_CAP = 300;

function summarizeToolInput(tool, input) {

  if (!input || typeof input !== 'object') return null;

  let raw;

  switch (tool) {

    case 'Bash':

      raw = typeof input.command === 'string' ? input.command : compactJson(input);

      break;

    case 'Edit':

      raw = typeof input.new_string === 'string' ? input.new_string : compactJson(input);

      break;

    case 'Write':

      raw = typeof input.content === 'string' ? input.content : compactJson(input);

      break;

    case 'WebFetch':

      raw = [input.url, input.prompt].filter((v) => typeof v === 'string').join(' ') || compactJson(input);

      break;

    default:

      raw = compactJson(input);

  }

  if (!raw) return null;

  raw = raw.replace(/\s+/g, ' ').trim();

  if (!raw) return null;

  return raw.length > INPUT_CAP ? `${raw.slice(0, INPUT_CAP)}...` : raw;

}

function compactJson(value) {

  try {

    return JSON.stringify(value);

  } catch {

    return null;

  }

}

function flattenUserContent(content) {

  if (typeof content === 'string') {

    return { text: content, hasImage: false, hasToolResult: false, hasOnlyToolResult: false, toolResults: [] };

  }

  if (!Array.isArray(content)) {

    return { text: '', hasImage: false, hasToolResult: false, hasOnlyToolResult: false, toolResults: [] };

  }

  let text = '';

  const toolResults = [];

  let others = 0;

  let images = 0;

  for (const block of content) {

    if (!block || typeof block !== 'object') continue;

    if (block.type === 'text' && typeof block.text === 'string') {

      text += (text ? '\n' : '') + block.text;

      others++;

    } else if (block.type === 'tool_result') {

      const raw = block.content;

      let blockText = '';

      if (typeof raw === 'string') blockText = raw;

      else if (Array.isArray(raw)) {

        for (const part of raw) {

          if (part && typeof part === 'object' && typeof part.text === 'string') {

            blockText += (blockText ? '\n' : '') + part.text;

          } else if (typeof part === 'string') {

            blockText += (blockText ? '\n' : '') + part;

          }

        }

      }

      toolResults.push({

        toolUseId: typeof block.tool_use_id === 'string' ? block.tool_use_id : null,

        isError: block.is_error === true,