@subvalue/cli 0.1.2 → 0.1.4

package/dist/packages/core/src/providers/codex/index.js

@@ -1,51 +1,218 @@
-import {baseRecord,hash,identifier,modelId,timestamp,token,track} from '../../metadata.js';
-import {emptyDiagnostics,                                 } from '../../types.js';
+import {
+  baseRecord,
+  hash,
+  identifier,
+  isObject,
+  modelId,
+  timestamp,
+  token,
+  track,
+} from '../../metadata.js';
+import { emptyDiagnostics,                                    } from '../../types.js';
                                               
-                                                                                                                                                                                                                
-export const codexState = ()             => ({thread:null,session:null,model:null,project:null,boundary:null,previous:null,turn:null,segment:0,diagnostics:emptyDiagnostics()});
-const keys = ['input_tokens','cached_input_tokens','cache_write_input_tokens','output_tokens','reasoning_output_tokens','total_tokens'];
-const counters = (v     )                  => v && typeof v==='object' ? Object.fromEntries(keys.map(k=>[k,token(v[k])])) : null;
-export function parseCodex(o     , s            , ref        , lineNumber        )                     {
-  if(!o || typeof o!=='object')return null;const p=o.payload;
-  if(!p || typeof p!=='object')return null;
+                             
+                        
+                         
+                       
+                         
+                          
+                            
+                      
+                  
+                           
+ 
+export const codexState = ()             => ({
+  thread: null,
+  session: null,
+  model: null,
+  project: null,
+  boundary: null,
+  previous: null,
+  turn: null,
+  segment: 0,
+  diagnostics: emptyDiagnostics(),
+});
+const keys = [
+  'input_tokens',
+  'cached_input_tokens',
+  'cache_write_input_tokens',
+  'output_tokens',
+  'reasoning_output_tokens',
+  'total_tokens',
+];
+const counters = (value         )                  =>
+  isObject(value) ? Object.fromEntries(keys.map((key) => [key, token(value[key])])) : null;
+export function parseCodex(
+  event         ,
+  state            ,
+  sourceReference        ,
+  lineNumber        ,
+)                     {
+  if (!isObject(event)) return null;
+  const payload = event.payload;
+  if (!isObject(payload)) return null;
+  const ordinal = token(event.ordinal);
   // Inherited metadata must not overwrite the child's identity or model either.
-  if(s.boundary!==null&&token(o.ordinal)!==null&&o.ordinal<s.boundary){if(o.type==='event_msg'&&p.type==='token_count')s.diagnostics.inherited++;return null;}
-  if(o.type==='session_meta'){
-    const thread=identifier(p.id);if(thread&&s.thread&&thread!==s.thread){s.previous=null;s.boundary=null;s.model=null;s.project=null;s.turn=null;s.segment++;}
-    s.thread=thread??s.thread;s.session=identifier(p.session_id)??s.thread;
-    if(typeof p.cwd==='string')s.project=hash('project',p.cwd);
-    s.boundary=token(p.subagent_history_start_ordinal)??s.boundary;
-    s.model=modelId(p.model)??s.model;return null;
-  }
-  if(o.type==='turn_context') {s.model=modelId(p.model)??s.model;s.turn=identifier(p.turn_id)??s.turn;if(typeof p.cwd==='string')s.project=hash('project',p.cwd);return null;}
-  if(o.type!=='event_msg'||p.type!=='token_count')return null;
-  if(s.boundary!==null){if(token(o.ordinal)===null){s.diagnostics.unsupported++;return null;}if(o.ordinal<s.boundary){s.diagnostics.inherited++;return null;}}
-  const info=p.info;if(!info || typeof info!=='object'){s.diagnostics.unsupported++;return null;}
-  const total=counters(info.total_token_usage),last=counters(info.last_token_usage);let usage              =null;let method='last';const notes         =[];
-  if(total&&s.previous){
-    const comparable=keys.filter(k=>total[k]!==null&&s.previous [k]!==null);
-    if(comparable.length&&comparable.every(k=>total[k]===s.previous [k])){s.diagnostics.repeated++;return null;}
-    if(comparable.some(k=>total[k] <s.previous [k] )){
-      s.segment++;s.diagnostics.resets++;notes.push('counter-reset');usage=last;method='reset-last';
-      if(!usage){usage={...total};notes.push('reset-without-last');}
-    }else{
-      usage=Object.fromEntries(keys.map(k=>[k,total[k]!==null&&s.previous [k]!==null?total[k] -s.previous [k] :null]));method='cumulative-delta';
-      if(last&&keys.some(k=>usage [k]!==null&&last[k]!==null&&usage [k]!==last[k]))notes.push('last-delta-disagreement');
+  if (state.boundary !== null && ordinal !== null && ordinal < state.boundary) {
+    if (event.type === 'event_msg' && payload.type === 'token_count') state.diagnostics.inherited++;
+    return null;
+  }
+  if (event.type === 'session_meta') {
+    const thread = identifier(payload.id);
+    if (thread && state.thread && thread !== state.thread) {
+      state.previous = null;
+      state.boundary = null;
+      state.model = null;
+      state.project = null;
+      state.turn = null;
+      state.segment++;
+    }
+    state.thread = thread ?? state.thread;
+    state.session = identifier(payload.session_id) ?? state.thread;
+    if (typeof payload.cwd === 'string') state.project = hash('project', payload.cwd);
+    state.boundary = token(payload.subagent_history_start_ordinal) ?? state.boundary;
+    state.model = modelId(payload.model) ?? state.model;
+    return null;
+  }
+  if (event.type === 'turn_context') {
+    state.model = modelId(payload.model) ?? state.model;
+    state.turn = identifier(payload.turn_id) ?? state.turn;
+    if (typeof payload.cwd === 'string') state.project = hash('project', payload.cwd);
+    return null;
+  }
+  if (event.type !== 'event_msg' || payload.type !== 'token_count') return null;
+  if (state.boundary !== null) {
+    if (ordinal === null) {
+      state.diagnostics.unsupported++;
+      return null;
+    }
+    if (ordinal < state.boundary) {
+      state.diagnostics.inherited++;
+      return null;
+    }
+  }
+  const info = payload.info;
+  if (!isObject(info)) {
+    state.diagnostics.unsupported++;
+    return null;
+  }
+  const total = counters(info.total_token_usage),
+    last = counters(info.last_token_usage);
+  let usage                  = null;
+  let method = 'last';
+  const notes           = [];
+  if (total && state.previous) {
+    const comparable = keys.filter((key) => total[key] !== null && state.previous [key] !== null);
+    if (comparable.length && comparable.every((key) => total[key] === state.previous [key])) {
+      state.diagnostics.repeated++;
+      return null;
+    }
+    if (comparable.some((key) => total[key]  < state.previous [key] )) {
+      state.segment++;
+      state.diagnostics.resets++;
+      notes.push('counter-reset');
+      usage = last;
+      method = 'reset-last';
+      if (!usage) {
+        usage = { ...total };
+        notes.push('reset-without-last');
+      }
+    } else {
+      usage = Object.fromEntries(
+        keys.map((key) => [
+          key,
+          total[key] !== null && state.previous [key] !== null
+            ? total[key]  - state.previous [key] 
+            : null,
+        ]),
+      );
+      method = 'cumulative-delta';
+      if (
+        last &&
+        keys.some((key) => usage [key] !== null && last[key] !== null && usage [key] !== last[key])
+      )
+        notes.push('last-delta-disagreement');
     }
-  }else if(last){usage=last;if(total&&keys.some(k=>last[k]!==null&&total[k]!==null&&last[k]!==total[k]))notes.push('nonzero-starting-baseline');}
-  else if(total){usage=total;method='initial-cumulative';notes.push('initial-cumulative-only');}
-  if(total)s.previous=total;
-  if(!usage){s.diagnostics.unsupported++;return null;}
-  const event=hash(s.thread??ref,token(o.ordinal)??lineNumber,timestamp(o.timestamp),s.segment,usage);
-  const r=baseRecord('codex',ref,event);r.timestamp=timestamp(o.timestamp);r.thread_id=s.thread;r.session_id=s.session;r.request_id=null;r.model_raw=s.model;r.project_identifier_hash=s.project;r.source_schema=`codex.token_count.v1/${method}`;r.notes=notes;
-  r.input_tokens=usage.input_tokens;r.cached_input_tokens=usage.cached_input_tokens;r.cache_creation_tokens=usage.cache_write_input_tokens;r.output_tokens=usage.output_tokens;r.reasoning_tokens=usage.reasoning_output_tokens;r.total_tokens=usage.total_tokens;
+  } else if (last) {
+    usage = last;
+    if (
+      total &&
+      keys.some((key) => last[key] !== null && total[key] !== null && last[key] !== total[key])
+    )
+      notes.push('nonzero-starting-baseline');
+  } else if (total) {
+    usage = total;
+    method = 'initial-cumulative';
+    notes.push('initial-cumulative-only');
+  }
+  if (total) state.previous = total;
+  if (!usage) {
+    state.diagnostics.unsupported++;
+    return null;
+  }
+  const sourceEventId = hash(
+    state.thread ?? sourceReference,
+    token(event.ordinal) ?? lineNumber,
+    timestamp(event.timestamp),
+    state.segment,
+    usage,
+  );
+  const record = baseRecord('codex', sourceReference, sourceEventId);
+  record.timestamp = timestamp(event.timestamp);
+  record.thread_id = state.thread;
+  record.session_id = state.session;
+  record.request_id = null;
+  record.model_raw = state.model;
+  record.project_identifier_hash = state.project;
+  record.source_schema = `codex.token_count.v1/${method}`;
+  record.notes = notes;
+  record.input_tokens = usage.input_tokens;
+  record.cached_input_tokens = usage.cached_input_tokens;
+  record.cache_creation_tokens = usage.cache_write_input_tokens;
+  record.output_tokens = usage.output_tokens;
+  record.reasoning_tokens = usage.reasoning_output_tokens;
+  record.total_tokens = usage.total_tokens;
   // A positive total with zero components is not a zero-token request.
-  if(r.total_tokens!==null&&r.input_tokens!==null&&r.output_tokens!==null&&r.total_tokens!==r.input_tokens+r.output_tokens){
-    r.unallocated_total_tokens=Math.max(0,r.total_tokens-r.input_tokens-r.output_tokens);r.notes.push('unallocated-total');r.quality='INCOMPLETE';
-    if(r.input_tokens===0&&r.output_tokens===0&&r.total_tokens>0){r.input_tokens=null;r.output_tokens=null;r.cached_input_tokens=null;r.reasoning_tokens=null;r.cache_creation_tokens=null;}
-  }
-  if(r.input_tokens===null||r.cached_input_tokens===null||r.cache_creation_tokens===null||r.output_tokens===null||!r.timestamp||!r.model_raw)r.quality='INCOMPLETE';
-  if(r.cached_input_tokens!==null&&r.input_tokens!==null&&r.cached_input_tokens>r.input_tokens){r.quality='INCOMPLETE';r.notes.push('invalid-cache-subset');}
-  if(notes.includes('initial-cumulative-only')||notes.includes('reset-without-last'))r.quality='INCOMPLETE';
-  if(r.quality==='HIGH'&&notes.length)r.quality='MEDIUM';track(s.diagnostics,r);return r;
+  if (
+    record.total_tokens !== null &&
+    record.input_tokens !== null &&
+    record.output_tokens !== null &&
+    record.total_tokens !== record.input_tokens + record.output_tokens
+  ) {
+    record.unallocated_total_tokens = Math.max(
+      0,
+      record.total_tokens - record.input_tokens - record.output_tokens,
+    );
+    record.notes.push('unallocated-total');
+    record.quality = 'INCOMPLETE';
+    if (record.input_tokens === 0 && record.output_tokens === 0 && record.total_tokens > 0) {
+      record.input_tokens = null;
+      record.output_tokens = null;
+      record.cached_input_tokens = null;
+      record.reasoning_tokens = null;
+      record.cache_creation_tokens = null;
+    }
+  }
+  if (
+    record.input_tokens === null ||
+    record.cached_input_tokens === null ||
+    record.cache_creation_tokens === null ||
+    record.output_tokens === null ||
+    !record.timestamp ||
+    !record.model_raw
+  )
+    record.quality = 'INCOMPLETE';
+  if (
+    record.cached_input_tokens !== null &&
+    record.input_tokens !== null &&
+    record.cached_input_tokens > record.input_tokens
+  ) {
+    record.quality = 'INCOMPLETE';
+    record.notes.push('invalid-cache-subset');
+  }
+  if (notes.includes('initial-cumulative-only') || notes.includes('reset-without-last'))
+    record.quality = 'INCOMPLETE';
+  if (record.quality === 'HIGH' && notes.length) record.quality = 'MEDIUM';
+  track(state.diagnostics, record);
+  return record;
 }

package/dist/packages/core/src/scanner.js

@@ -1,60 +1,240 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import {createHash} from 'node:crypto';
-import {sourceRoots,detectedProviders,enumerate,openAllowedFile} from './security.js';
-import {hash} from './metadata.js';
-                                                   
-import {codexState,parseCodex,               } from './providers/codex/index.js';
-import {claudeState,parseClaude,                } from './providers/claude/index.js';
-import {emptyDiagnostics,                                                } from './types.js';
-import {usageMetadata} from './usage-json.js';
-export const PARSER_VERSION='2';
-const MAX_LINE=16*1024*1024;
-const READ_BLOCK=1024*1024;
-const CODEX_MARKERS=['"session_meta"','"turn_context"','"token_count"'].map(value=>Buffer.from(value));
-function fingerprint(fd       ,start       ,len       )       {const b=Buffer.alloc(Math.max(0,len));const n=fs.readSync(fd,b,0,b.length,start);return createHash('sha256').update(b.subarray(0,n)).digest('hex');}
-function combine(to            ,from            ){for(const k of ['malformed','inherited','repeated','resets','oversize','unsupported','records']         )to[k]+=from[k];to.partialTail ||= from.partialTail;if(from.first)to.first=!to.first||from.first<to.first?from.first:to.first;if(from.last)to.last=!to.last||from.last>to.last?from.last:to.last;}
-                                                                                                                    
-export async function scan(store      ,options                                                  ={})                        {
-  const home=options.home??os.homedir(),detected=detectedProviders(home);const statuses               =(['codex','claude']              ).map(provider=>({provider,detected:detected[provider],files:0,scanned:0,cached:0,errors:0,skippedLinks:0,missingFiles:0,diagnostics:emptyDiagnostics()}));
-  const seen=new Set        ();let bytes=0;
-  for(const root of sourceRoots(home)){const status=statuses.find(s=>s.provider===root.provider) ;const found=enumerate(root);status.files+=found.files.length;status.errors+=found.errors;status.skippedLinks+=found.skippedLinks;
-    for(const file of found.files){const ref=hash(root.safeLabel,path.relative(root.directory,file));seen.add(ref);let fd                 ;let stream                        ;let transaction=false;
-      try{fd=openAllowedFile(root,file);const stat=fs.fstatSync(fd);let cp=store.checkpoint(ref);const identity=`${stat.dev}:${stat.ino}:${PARSER_VERSION}`;
-        if(cp&&cp.size===stat.size&&cp.mtime===stat.mtimeMs&&cp.identity===identity&&fingerprint(fd,0,Math.min(4096,cp.offset))===cp.head&&fingerprint(fd,Math.max(0,cp.offset-4096),Math.min(4096,cp.offset))===cp.tail){status.cached++;combine(status.diagnostics,cp.state.diagnostics);continue;}
-        if(cp){const headLen=Math.min(4096,cp.offset);const tailStart=Math.max(0,cp.offset-4096);const appendSafe=stat.size>cp.size&&identity===cp.identity&&fingerprint(fd,0,headLen)===cp.head&&fingerprint(fd,tailStart,cp.offset-tailStart)===cp.tail;if(!appendSafe)cp=null;}
-        const state                       =cp?cp.state:root.provider==='codex'?codexState():claudeState();state.diagnostics.partialTail=false;
-        let offset=cp?.offset??0,lineNumber=cp?.line??0;let parts         =[],length=0,dropping=false,consumed=0;const start=offset;store.db.exec('BEGIN IMMEDIATE');transaction=true;if(!cp)store.clearSource(ref);
+import { createHash } from 'node:crypto';
+import { sourceRoots, detectedProviders, enumerate, openAllowedFile } from './security.js';
+import { hash } from './metadata.js';
+                                                      
+import { codexState, parseCodex,                 } from './providers/codex/index.js';
+import { claudeState, parseClaude,                  } from './providers/claude/index.js';
+import { emptyDiagnostics,                                                    } from './types.js';
+import { usageMetadata } from './usage-json.js';
+export const PARSER_VERSION = '2';
+const MAX_LINE = 16 * 1024 * 1024;
+const READ_BLOCK = 1024 * 1024;
+const CODEX_MARKERS = ['"session_meta"', '"turn_context"', '"token_count"'].map((value) =>
+  Buffer.from(value),
+);
+function fingerprint(fd        , start        , len        )         {
+  const b = Buffer.alloc(Math.max(0, len));
+  const n = fs.readSync(fd, b, 0, b.length, start);
+  return createHash('sha256').update(b.subarray(0, n)).digest('hex');
+}
+function combine(to             , from             ) {
+  for (const k of [
+    'malformed',
+    'inherited',
+    'repeated',
+    'resets',
+    'oversize',
+    'unsupported',
+    'records',
+  ]         )
+    to[k] += from[k];
+  to.partialTail ||= from.partialTail;
+  if (from.first) to.first = !to.first || from.first < to.first ? from.first : to.first;
+  if (from.last) to.last = !to.last || from.last > to.last ? from.last : to.last;
+}
+                               
+                     
+                
+                
+                
+                                 
+ 
+export async function scan(
+  store       ,
+  options                                                            = {},
+)                          {
+  const home = options.home ?? os.homedir(),
+    detected = detectedProviders(home);
+  const statuses                 = (['codex', 'claude']              ).map((provider) => ({
+    provider,
+    detected: detected[provider],
+    files: 0,
+    scanned: 0,
+    cached: 0,
+    errors: 0,
+    skippedLinks: 0,
+    missingFiles: 0,
+    diagnostics: emptyDiagnostics(),
+  }));
+  const seen = new Set        ();
+  let bytes = 0;
+  for (const root of sourceRoots(home)) {
+    const status = statuses.find((s) => s.provider === root.provider) ;
+    const found = enumerate(root);
+    status.files += found.files.length;
+    status.errors += found.errors;
+    status.skippedLinks += found.skippedLinks;
+    for (const file of found.files) {
+      const ref = hash(root.safeLabel, path.relative(root.directory, file));
+      seen.add(ref);
+      let fd                    ;
+      let stream                           ;
+      let transaction = false;
+      try {
+        fd = openAllowedFile(root, file);
+        const stat = fs.fstatSync(fd);
+        let cp = store.checkpoint(ref);
+        const identity = `${stat.dev}:${stat.ino}:${PARSER_VERSION}`;
+        if (
+          cp &&
+          cp.size === stat.size &&
+          cp.mtime === stat.mtimeMs &&
+          cp.identity === identity &&
+          fingerprint(fd, 0, Math.min(4096, cp.offset)) === cp.head &&
+          fingerprint(fd, Math.max(0, cp.offset - 4096), Math.min(4096, cp.offset)) === cp.tail
+        ) {
+          status.cached++;
+          combine(status.diagnostics, cp.state.diagnostics);
+          continue;
+        }
+        if (cp) {
+          const headLen = Math.min(4096, cp.offset);
+          const tailStart = Math.max(0, cp.offset - 4096);
+          const appendSafe =
+            stat.size > cp.size &&
+            identity === cp.identity &&
+            fingerprint(fd, 0, headLen) === cp.head &&
+            fingerprint(fd, tailStart, cp.offset - tailStart) === cp.tail;
+          if (!appendSafe) cp = null;
+        }
+        const state                           = cp
+          ? cp.state
+          : root.provider === 'codex'
+            ? codexState()
+            : claudeState();
+        state.diagnostics.partialTail = false;
+        let offset = cp?.offset ?? 0,
+          lineNumber = cp?.line ?? 0;
+        let parts           = [],
+          length = 0,
+          dropping = false,
+          consumed = 0;
+        const start = offset;
+        store.db.exec('BEGIN IMMEDIATE');
+        transaction = true;
+        if (!cp) store.clearSource(ref);
         // The stream owns only the already validated read-only file descriptor.
-        if(stat.size>start){stream=fs.createReadStream(file,{fd,autoClose:false,start,end:stat.size-1,highWaterMark:READ_BLOCK});for await(const chunk of stream.iterator({destroyOnReturn:false})){bytes+=chunk.length;let cursor=0;while(cursor<chunk.length){const newline=chunk.indexOf(10,cursor);const end=newline<0?chunk.length:newline;const part=chunk.subarray(cursor,end);if(!dropping){if(length+part.length>MAX_LINE){parts=[];length=0;dropping=true;state.diagnostics.oversize++;}else if(part.length){parts.push(part);length+=part.length;}}
-            if(newline<0)break;lineNumber++;
-            const absoluteEnd=start+consumed+newline+1;offset=absoluteEnd;
-            if(!dropping&&length){const buffer=parts.length===1?parts[0]:Buffer.concat(parts,length);
-              // Native byte searches avoid decoding conversation-only Codex lines.
-              // This is a conservative prefilter; the existing schema check still
-              // decides relevance, including malformed metadata and quoted markers.
-              const candidate=root.provider==='claude'||CODEX_MARKERS.some(marker=>buffer.includes(marker));
-              if(candidate){let o    =null;
-                try{o=usageMetadata(buffer,root.provider);}catch{state.diagnostics.malformed++;}
-                if(o){const r=root.provider==='codex'?parseCodex(o,state              ,ref,lineNumber):parseClaude(o,state               ,ref,lineNumber);if(r){const result=store.put(r,ref);if(result!=='new')state.diagnostics.repeated++;}}
+        if (stat.size > start) {
+          stream = fs.createReadStream(file, {
+            fd,
+            autoClose: false,
+            start,
+            end: stat.size - 1,
+            highWaterMark: READ_BLOCK,
+          });
+          for await (const chunk of stream.iterator({ destroyOnReturn: false })) {
+            bytes += chunk.length;
+            let cursor = 0;
+            while (cursor < chunk.length) {
+              const newline = chunk.indexOf(10, cursor);
+              const end = newline < 0 ? chunk.length : newline;
+              const part = chunk.subarray(cursor, end);
+              if (!dropping) {
+                if (length + part.length > MAX_LINE) {
+                  parts = [];
+                  length = 0;
+                  dropping = true;
+                  state.diagnostics.oversize++;
+                } else if (part.length) {
+                  parts.push(part);
+                  length += part.length;
+                }
               }
-            }parts=[];length=0;dropping=false;cursor=newline+1;
-          }consumed+=chunk.length;options.onProgress?.({provider:root.provider,files:status.scanned+status.cached,total:status.files,bytes,phase:'scanning'});
-        }}
-        if(length||dropping)state.diagnostics.partialTail=true;
-        const checkpoint           ={ref,size:stat.size,mtime:stat.mtimeMs,offset,line:lineNumber,head:fingerprint(fd,0,Math.min(4096,offset)),tail:fingerprint(fd,Math.max(0,offset-4096),Math.min(4096,offset)),state,identity};
+              if (newline < 0) break;
+              lineNumber++;
+              const absoluteEnd = start + consumed + newline + 1;
+              offset = absoluteEnd;
+              if (!dropping && length) {
+                const buffer = parts.length === 1 ? parts[0] : Buffer.concat(parts, length);
+                // Native byte searches avoid decoding conversation-only Codex lines.
+                // This is a conservative prefilter; the existing schema check still
+                // decides relevance, including malformed metadata and quoted markers.
+                const candidate =
+                  root.provider === 'claude' ||
+                  CODEX_MARKERS.some((marker) => buffer.includes(marker));
+                if (candidate) {
+                  let o          = null;
+                  try {
+                    o = usageMetadata(buffer, root.provider);
+                  } catch {
+                    state.diagnostics.malformed++;
+                  }
+                  if (o) {
+                    const r =
+                      root.provider === 'codex'
+                        ? parseCodex(o, state              , ref, lineNumber)
+                        : parseClaude(o, state               , ref, lineNumber);
+                    if (r) {
+                      const result = store.put(r, ref);
+                      if (result !== 'new') state.diagnostics.repeated++;
+                    }
+                  }
+                }
+              }
+              parts = [];
+              length = 0;
+              dropping = false;
+              cursor = newline + 1;
+            }
+            consumed += chunk.length;
+            options.onProgress?.({
+              provider: root.provider,
+              files: status.scanned + status.cached,
+              total: status.files,
+              bytes,
+              phase: 'scanning',
+            });
+          }
+        }
+        if (length || dropping) state.diagnostics.partialTail = true;
+        const checkpoint             = {
+          ref,
+          size: stat.size,
+          mtime: stat.mtimeMs,
+          offset,
+          line: lineNumber,
+          head: fingerprint(fd, 0, Math.min(4096, offset)),
+          tail: fingerprint(fd, Math.max(0, offset - 4096), Math.min(4096, offset)),
+          state,
+          identity,
+        };
         // New records always receive a source association in put(); neither a
         // fresh import nor an append creates orphans needing a global sweep.
-        store.saveCheckpoint(checkpoint);store.db.exec('COMMIT');transaction=false;status.scanned++;combine(status.diagnostics,state.diagnostics);
-      }catch{if(transaction)store.db.exec('ROLLBACK');status.errors++;const previous=store.checkpoint(ref);if(previous)combine(status.diagnostics,previous.state.diagnostics);}finally{
+        store.saveCheckpoint(checkpoint);
+        store.db.exec('COMMIT');
+        transaction = false;
+        status.scanned++;
+        combine(status.diagnostics, state.diagnostics);
+      } catch {
+        if (transaction) store.db.exec('ROLLBACK');
+        status.errors++;
+        const previous = store.checkpoint(ref);
+        if (previous) combine(status.diagnostics, previous.state.diagnostics);
+      } finally {
         // A failed loop must not implicitly close the descriptor and then close
         // it again here. Await the stream's single close, including pending reads.
-        if(stream)await new Promise      (resolve=>stream .close(()=>resolve()));else if(fd!==undefined)fs.closeSync(fd);
+        if (stream) await new Promise      ((resolve) => stream .close(() => resolve()));
+        else if (fd !== undefined) fs.closeSync(fd);
       }
     }
   }
   // Missing sources are retained as cached history, never silently treated as zero.
-  for(const cp of store.allCheckpoints())if(!seen.has(cp.ref)){const provider=(cp.state              ).thread!==undefined?'codex':'claude';statuses.find(s=>s.provider===provider) .missingFiles++;}
-  store.save('sources',statuses);store.save('lastScan',new Date().toISOString());options.onProgress?.({provider:'codex',files:statuses.reduce((n,s)=>n+s.scanned+s.cached,0),total:statuses.reduce((n,s)=>n+s.files,0),bytes,phase:'complete'});return statuses;
+  for (const cp of store.allCheckpoints())
+    if (!seen.has(cp.ref)) {
+      const provider = (cp.state              ).thread !== undefined ? 'codex' : 'claude';
+      statuses.find((s) => s.provider === provider) .missingFiles++;
+    }
+  store.save('sources', statuses);
+  store.save('lastScan', new Date().toISOString());
+  options.onProgress?.({
+    provider: 'codex',
+    files: statuses.reduce((n, s) => n + s.scanned + s.cached, 0),
+    total: statuses.reduce((n, s) => n + s.files, 0),
+    bytes,
+    phase: 'complete',
+  });
+  return statuses;
 }