@inixiative/archive 0.12.1 → 0.14.0

package/src/collector.ts

@@ -1,10 +1,22 @@
-import { closeSync, existsSync, lstatSync, openSync, readdirSync, readSync } from 'node:fs';
-import { isAbsolute, join, resolve } from 'node:path';
+import {
+  closeSync,
+  existsSync,
+  lstatSync,
+  openSync,
+  readdirSync,
+  readFileSync,
+  readSync,
+  realpathSync,
+} from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { importTranscriptFile } from './import-file';
-import { archiveKey } from './index';
+import { archiveKey, archiveSnapshotSchema, snapshotDigest, UNROUTED } from './index';
 import type { ArchiveClient } from './remote';
 import { type AtlasFileConcepts, atlasTags, provenanceReferences } from './tags';
 
+export { UNROUTED } from './index';
+
 export interface CollectionSource {
   directory: string;
   source: 'codex' | 'claude-code';
@@ -12,12 +24,42 @@ export interface CollectionSource {
   projectId: string;
   /** Also match the git worktrees of each root; nested checkouts stay separate. */
   worktrees?: boolean;
+  /** Also match directories below each root, unless a more specific root claims them. */
+  subdirectories?: boolean;
+  /** Take every session no other collector of this source claims, as projectId `unrouted`. */
+  catchAll?: boolean;
   /** Tag sessions with the Atlas concepts of files they touched, from `atlas graph` in the session's checkout. */
   atlas?: boolean;
   tags?: string[];
 }
 
-function files(directory: string): string[] {
+/**
+ * Where sessions are never swept in by a subdirectory or catch-all match: temp directories (test
+ * fixtures, agent scratchpads) and Foundry's decision receipts. An exact root is explicit and wins.
+ * Absolute entries match the directory and below; relative ones match those path segments anywhere.
+ */
+export const defaultExclusions = () => [
+  ...new Set(
+    ['/tmp', '/private/tmp', '/var/folders', '/private/var/folders', tmpdir()].flatMap((path) => {
+      try {
+        return [resolve(path), realpathSync(path)];
+      } catch {
+        return [resolve(path)];
+      }
+    }),
+  ),
+  '.foundry/decision-receipts',
+];
+export function excluded(cwd: string, exclusions: string[]) {
+  return exclusions.some((entry) =>
+    isAbsolute(entry)
+      ? cwd === resolve(entry) || cwd.startsWith(`${resolve(entry)}/`)
+      : `${cwd}/`.includes(`/${entry.replace(/^\/+|\/+$/g, '')}/`),
+  );
+}
+
+/** Every transcript (`.jsonl`) under a directory, in order, without following links. */
+export function transcriptFiles(directory: string): string[] {
   const result: string[] = [];
   const visit = (path: string) => {
     const stat = lstatSync(path);
@@ -29,10 +71,10 @@ function files(directory: string): string[] {
   return result;
 }
 
-type SessionMetadata = { cwd: string; branch?: string; repository?: string };
+export type SessionMetadata = { cwd: string; branch?: string; repository?: string };
 
-/** Match provider metadata, never text/tags/model suggestions. No implicit parent-directory routing. */
-function sessionMetadata(
+/** Provider metadata, never text/tags/model suggestions; `routeSession` decides where it goes. */
+export function sessionMetadata(
   file: string,
   source: CollectionSource['source'],
 ): SessionMetadata | undefined {
@@ -96,42 +138,204 @@ function worktreesOf(root: string): string[] {
 
 /** Exact directories this collection accepts, re-read each scan so new worktrees join. */
 export function collectionRoots(config: CollectionSource): Set<string> {
-  const roots = config.projectRoots.map((root) => resolve(root));
+  // Providers record the real path (macOS /tmp is /private/tmp), so roots match by it too.
+  const roots = config.projectRoots.flatMap((root) => {
+    try {
+      return [...new Set([resolve(root), realpathSync(root)])];
+    } catch {
+      return [resolve(root)];
+    }
+  });
   return new Set(config.worktrees ? [...roots, ...roots.flatMap(worktreesOf)] : roots);
 }
 
+/**
+ * The collector a session's cwd belongs to. The longest matching root wins: a root matches its own
+ * directory (and worktrees), and with `subdirectories` the directories below it. Ties go to the
+ * first declared. Excluded directories match only exact roots. Unclaimed sessions go to the first
+ * catch-all.
+ */
+export function routeSession(
+  cwd: string,
+  collectors: CollectionSource[],
+  options: { exclude?: string[]; roots?: (collector: CollectionSource) => Set<string> } = {},
+) {
+  const rootsOf = options.roots ?? collectionRoots;
+  const broad = !excluded(cwd, options.exclude ?? defaultExclusions());
+  let best: { collector: CollectionSource; length: number } | undefined;
+  for (const collector of collectors) {
+    if (collector.catchAll) continue;
+    for (const root of rootsOf(collector)) {
+      const matches =
+        cwd === root || (broad && collector.subdirectories && cwd.startsWith(`${root}/`));
+      if (matches && (!best || root.length > best.length))
+        best = { collector, length: root.length };
+    }
+  }
+  if (best) return best.collector;
+  return broad ? collectors.find((c) => c.catchAll) : undefined;
+}
+
 /** Where collected sessions go: an Archive server, or a store in-process. */
 export type ArchiveWriter = Pick<ArchiveClient, 'sourceId' | 'head' | 'capture'>;
 
-export async function collectSessions(archive: ArchiveWriter, config: CollectionSource) {
+/**
+ * The access path the harness's login implies when a transcript is silent, read from the harness
+ * home that owns the history directory (`<claude config>/projects`, `<codex home>/sessions`):
+ * Claude Code's subscription login (`oauthAccount`) unless its settings supply an API key, and
+ * Codex's `auth.json` mode. Undefined when neither says; throws when a file exists but cannot be
+ * read, so a bad read never relabels sessions.
+ */
+export function harnessAccess(
+  source: CollectionSource['source'],
+  directory: string,
+): 'subscription' | 'api' | undefined {
+  const json = (path: string) =>
+    existsSync(path) ? JSON.parse(readFileSync(path, 'utf8')) : undefined;
+  const harnessHome = dirname(resolve(directory));
+  if (source === 'claude-code') {
+    const settings = json(join(harnessHome, 'settings.json'));
+    if (settings?.apiKeyHelper || settings?.env?.ANTHROPIC_API_KEY) return 'api';
+    // The default config directory keeps its login beside it, in ~/.claude.json.
+    const login =
+      harnessHome === join(homedir(), '.claude')
+        ? join(homedir(), '.claude.json')
+        : join(harnessHome, '.claude.json');
+    const account = json(login)?.oauthAccount;
+    return account && typeof account === 'object' ? 'subscription' : undefined;
+  }
+  const auth = json(join(harnessHome, 'auth.json'));
+  if (auth?.auth_mode === 'chatgpt' || auth?.tokens) return 'subscription';
+  if (auth?.auth_mode === 'apikey' || auth?.OPENAI_API_KEY) return 'api';
+  return undefined;
+}
+
+/**
+ * What a watching collector remembers between scans: each file's size and mtime with the outcome,
+ * so an untouched file is neither re-read nor re-sent. Keyed by the routing and archive it was
+ * decided under; a stored session is re-checked against the server now and then, so one deleted
+ * there is captured again.
+ */
+export type CollectorCache = Map<
+  string,
+  {
+    size: number;
+    mtimeMs: number;
+    routing: string;
+    outcome: 'unchanged' | 'skipped' | 'failed';
+    meta?: SessionMetadata;
+    stored?: { id: string; digest: string; checkedAt: number };
+  }
+>;
+const REVALIDATE_MS = 10 * 60_000;
+
+export interface CollectOptions {
+  /** Every collector of this source and directory, this one included; the most specific wins. */
+  peers?: CollectionSource[];
+  exclude?: string[];
+  cache?: CollectorCache;
+  /** The harness login's access path; defaults to reading the history directory's harness home. */
+  harness?: (
+    source: CollectionSource['source'],
+    directory: string,
+  ) => 'subscription' | 'api' | undefined;
+  now?: () => number;
+}
+
+/** A rejection the same snapshot will get again: invalid input or a refused write, not an outage. */
+const deterministic = (error: unknown) => {
+  const status = (error as { status?: unknown } | null)?.status;
+  return (
+    (error instanceof Error && error.name === 'ZodError') ||
+    (typeof status === 'number' && status >= 400 && status < 500 && status !== 409)
+  );
+};
+
+export async function collectSessions(
+  archive: ArchiveWriter,
+  config: CollectionSource,
+  options: CollectOptions = {},
+) {
   const sourceId = await archive.sourceId();
-  const roots = collectionRoots(config);
+  const now = options.now ?? Date.now;
+  const peers = options.peers ?? [config];
+  const exclude = options.exclude ?? defaultExclusions();
+  const cache: CollectorCache = options.cache ?? new Map();
+  const routing = JSON.stringify([sourceId, config, peers, exclude]);
   const result = { imported: 0, unchanged: 0, skipped: 0, failed: 0 };
   // Per scan: checkouts change between scans.
+  const rootSets = new Map<CollectionSource, Set<string>>();
+  const roots = (collector: CollectionSource) => {
+    if (!rootSets.has(collector)) rootSets.set(collector, collectionRoots(collector));
+    return rootSets.get(collector)!;
+  };
+  const routes = new Map<string, CollectionSource | undefined>();
   const repositories = new Map<string, string | undefined>();
   const graphs = new Map<string, AtlasFileConcepts | undefined>();
-  for (const file of files(config.directory)) {
+  let harness: 'subscription' | 'api' | undefined | null = null;
+  for (const file of transcriptFiles(config.directory)) {
     try {
-      const meta = sessionMetadata(file, config.source);
-      // Exact root selection avoids sweeping nested checkouts belonging to another organization.
-      if (!meta || !roots.has(meta.cwd)) {
+      const before = lstatSync(file);
+      const known = cache.get(file);
+      if (
+        known?.size === before.size &&
+        known.mtimeMs === before.mtimeMs &&
+        known.routing === routing
+      ) {
+        const stored = known.stored;
+        if (!stored || now() - stored.checkedAt < REVALIDATE_MS) {
+          result[known.outcome]++;
+          continue;
+        }
+        if ((await archive.head(stored.id))?.digest === stored.digest) {
+          stored.checkedAt = now();
+          result.unchanged++;
+          continue;
+        }
+      }
+      const remember = (
+        outcome: 'unchanged' | 'skipped' | 'failed',
+        meta?: SessionMetadata,
+        stored?: { id: string; digest: string },
+      ) =>
+        cache.set(file, {
+          size: before.size,
+          mtimeMs: before.mtimeMs,
+          routing,
+          outcome,
+          meta,
+          ...(stored ? { stored: { ...stored, checkedAt: now() } } : {}),
+        });
+      // A transcript's first cwd never changes, so it is read once per file.
+      const meta = known?.meta ?? sessionMetadata(file, config.source);
+      if (!meta) {
         result.skipped++;
+        remember('skipped');
         continue;
       }
-      const before = lstatSync(file);
-      const snapshot = importTranscriptFile(file, {
-        source: config.source,
-        sourceId,
-        projectId: config.projectId,
-      });
-      const after = lstatSync(file);
-      if (before.size !== after.size || before.mtimeMs !== after.mtimeMs) {
+      if (!routes.has(meta.cwd))
+        routes.set(meta.cwd, routeSession(meta.cwd, peers, { exclude, roots }));
+      if (routes.get(meta.cwd) !== config) {
         result.skipped++;
+        remember('skipped', meta);
         continue;
       }
-      const old = await archive.head(archiveKey(snapshot));
-      if (old && old.projectId !== config.projectId) {
+      let snapshot: ReturnType<typeof importTranscriptFile>;
+      try {
+        snapshot = importTranscriptFile(file, {
+          source: config.source,
+          sourceId,
+          projectId: config.projectId,
+        });
+      } catch {
+        // The same bytes fail the same way; a partial file is retried once it changes.
         result.failed++;
+        remember('failed', meta);
+        continue;
+      }
+      const after = lstatSync(file);
+      if (before.size !== after.size || before.mtimeMs !== after.mtimeMs) {
+        result.skipped++;
         continue;
       }
       const { cwd } = meta;
@@ -139,15 +343,54 @@ export async function collectSessions(archive: ArchiveWriter, config: Collection
       if (config.atlas && !graphs.has(cwd)) graphs.set(cwd, atlasGraph(cwd));
       const graph = graphs.get(cwd);
       snapshot.tags = [
-        ...new Set([...(config.tags ?? []), ...(graph ? atlasTags(snapshot, graph, roots) : [])]),
+        ...new Set([
+          ...(config.tags ?? []),
+          ...(graph ? atlasTags(snapshot, graph, roots(config)) : []),
+        ]),
       ].slice(0, 100);
       const references = provenanceReferences({
         branch: meta.branch,
         repository: meta.repository ?? repositories.get(cwd),
       });
       if (references.length) snapshot.references = references;
-      if ((await archive.capture(snapshot)).changed) result.imported++;
-      else result.unchanged++;
+      if (snapshot.runtime?.accessPath === 'unknown') {
+        if (harness === null)
+          harness = (options.harness ?? harnessAccess)(config.source, config.directory);
+        if (harness)
+          snapshot.runtime = { ...snapshot.runtime, accessPath: harness, evidence: 'harness' };
+      }
+      const id = archiveKey(snapshot);
+      const old = await archive.head(id);
+      // A session belongs to one project; only one the catch-all held moves to its routed project.
+      if (old && old.projectId !== config.projectId && old.projectId !== UNROUTED) {
+        result.failed++;
+        remember('failed', meta);
+        continue;
+      }
+      // An unchanged session is not sent again: the server already holds this digest.
+      // Digest what the server will: the schema orders keys, and fields set above were appended.
+      let digest: string;
+      try {
+        digest = snapshotDigest(archiveSnapshotSchema.parse(snapshot));
+      } catch {
+        // Over the archive's limits: the same bytes are refused again.
+        result.failed++;
+        remember('failed', meta);
+        continue;
+      }
+      if (old?.digest === digest) result.unchanged++;
+      else {
+        try {
+          const captured = await archive.capture(snapshot);
+          digest = captured.digest;
+          result[captured.changed ? 'imported' : 'unchanged']++;
+        } catch (error) {
+          result.failed++;
+          if (deterministic(error)) remember('failed', meta);
+          continue;
+        }
+      }
+      remember('unchanged', meta, { id, digest });
     } catch {
       result.failed++;
     } // Partial/malformed files remain intact and retry on the next scan.

package/src/config.ts

@@ -13,8 +13,13 @@ import {
 } from 'node:fs';
 import { dirname, isAbsolute, join } from 'node:path';
 import { z } from 'zod';
+import { UNROUTED } from './index';
 
-const projectId = z.string().min(1).max(256);
+const projectId = z
+  .string()
+  .min(1)
+  .max(256)
+  .refine((id) => id !== UNROUTED, `${UNROUTED} sessions stay on this machine`);
 /** A remote Archive this one syncs to directly with its server token. */
 const archiveDestination = z
   .strictObject({

package/src/import-file.ts

@@ -1,5 +1,6 @@
-import { closeSync, fstatSync, openSync, readSync } from 'node:fs';
+import { closeSync, existsSync, fstatSync, openSync, readFileSync, readSync } from 'node:fs';
 import { type ImportOptions, importTranscriptLines } from './import';
+import { archiveLineageSchema } from './index';
 
 /** Bound raw record memory while skipping unsupported payloads from long native histories. */
 export function importTranscriptFile(file: string, options: ImportOptions) {
@@ -41,5 +42,31 @@ export function importTranscriptFile(file: string, options: ImportOptions) {
       closeSync(descriptor);
     }
   }
-  return importTranscriptLines(lines(), options);
+  const snapshot = importTranscriptLines(lines(), options);
+  if (options.source === 'claude-code' && snapshot.lineage) {
+    const meta = subagentMeta(file);
+    if (meta) snapshot.lineage = archiveLineageSchema.parse({ ...snapshot.lineage, ...meta });
+  }
+  return snapshot;
+}
+
+/** Claude Code writes `agent-<id>.meta.json` beside a subagent transcript: its type, task and depth. */
+function subagentMeta(file: string) {
+  const path = file.replace(/\.jsonl$/, '.meta.json');
+  if (path === file || !existsSync(path)) return undefined;
+  let meta: Record<string, unknown>;
+  try {
+    meta = JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return undefined;
+  }
+  const text = (value: unknown, max: number) =>
+    typeof value === 'string' && value ? value.slice(0, max) : undefined;
+  const fields = {
+    agentType: text(meta.agentType, 200),
+    description: text(meta.description, 500),
+    toolUseId: text(meta.toolUseId, 256),
+    depth: Number.isInteger(meta.spawnDepth) ? (meta.spawnDepth as number) : undefined,
+  };
+  return Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== undefined));
 }

package/src/import.ts

@@ -1,4 +1,9 @@
-import { type ArchiveEntry, type ArchiveSnapshot, archiveSnapshotSchema } from './index';
+import {
+  type ArchiveEntry,
+  type ArchiveLineage,
+  type ArchiveSnapshot,
+  archiveSnapshotSchema,
+} from './index';
 
 export interface ImportOptions {
   source: 'codex' | 'claude-code';
@@ -27,7 +32,35 @@ const injectedTags = [
   'user_instructions',
   'permissions',
   'INSTRUCTIONS',
+  'codex_internal_context',
+  'heartbeat',
+  'in-app-browser-context',
+  'external_codex_apps_open_page',
+  'send_user_message_question_reply',
+  'turn_aborted',
 ].join('|');
+/** Prompts Codex writes in the user's role. */
+const injectedPreamble = /^(?:# In app browser:|The following is the Codex agent history)/;
+/**
+ * Nothing but blocks of harness-style tags such as `<codex_internal_context>`: `snake_case` or
+ * `kebab-case` names, unlike markup a person pastes. A linear scan, since a backtracking pattern is
+ * exponential on many sibling blocks.
+ */
+function onlyTagBlocks(text: string) {
+  const open = /\s*<([a-z][a-z0-9]*(?:[_-][a-z0-9]+)+)(?:\s[^>]*)?>/y;
+  let at = 0;
+  let blocks = 0;
+  while (at < text.length) {
+    open.lastIndex = at;
+    const match = open.exec(text);
+    if (!match) return blocks > 0 && !text.slice(at).trim();
+    const close = text.indexOf(`</${match[1]}>`, open.lastIndex);
+    if (close < 0) return false;
+    at = close + match[1]!.length + 3;
+    blocks++;
+  }
+  return blocks > 0;
+}
 const injectedBlock = new RegExp(`<(${injectedTags})(?:\\s[^>]*)?>[\\s\\S]*?</\\1>`, 'g');
 const injectedOpening = new RegExp(`^<(?:${injectedTags})(?:>|\\s)`);
 /** Foundry's native-session envelope; the person's text is the first User Message section. */
@@ -35,7 +68,7 @@ const foundryUserMessage =
   /^# User Message[ \t]*\n([\s\S]*?)(?=\n# (?:User Message|Assistant Message|Foundry Injection)[ \t]*\n|(?![\s\S]))/m;
 
 /** What the person typed in a user message, without injected content; undefined when nothing is left. */
-function typedPrompt(text: string) {
+export function typedPrompt(text: string) {
   let prompt = text
     .replace(injectedBlock, '')
     .replace(/<\/?pasted_content(?:\s[^>]*)?>/g, '')
@@ -43,7 +76,13 @@ function typedPrompt(text: string) {
     .trim();
   if (/^# (?:System Context|User Message)[ \t]*\n/.test(prompt))
     prompt = prompt.match(foundryUserMessage)?.[1].trim() ?? '';
-  if (!prompt || injectedOpening.test(prompt) || /^\[Request interrupted by user/.test(prompt))
+  if (
+    !prompt ||
+    injectedOpening.test(prompt) ||
+    injectedPreamble.test(prompt) ||
+    onlyTagBlocks(prompt) ||
+    /^\[Request interrupted by user/.test(prompt)
+  )
     return undefined;
   return prompt;
 }
@@ -66,6 +105,16 @@ export function importTranscriptLines(
   let contentBytes = 0;
   // Codex states the model per turn; Claude Code per assistant record.
   let turn: { model?: string; effort?: string } = {};
+  // A Codex session started by a script (codex exec, a custom originator) has no typed prompts.
+  let scripted = false;
+  let metaSeen = false;
+  let lineage: ArchiveLineage | undefined;
+  let provider: string | undefined = options.source === 'claude-code' ? 'anthropic' : undefined;
+  // Only a subscription's rate-limit windows prove the access path; an API key leaves no mark.
+  let subscription = false;
+  const text = (value: unknown) => (typeof value === 'string' && value ? value : undefined);
+  const optional = <K extends string>(key: K, value: string | undefined) =>
+    (value ? { [key]: value } : {}) as Partial<Record<K, string>>;
   for (const rawLine of lines) {
     index++;
     const line = rawLine.trim();
@@ -79,11 +128,52 @@ export function importTranscriptLines(
     if (!row || typeof row !== 'object' || Array.isArray(row))
       throw new Error(`Invalid transcript record at line ${index + 1}`);
     if (options.source === 'codex' && row.type === 'session_meta') {
-      const id = row.payload?.id;
+      const meta = row.payload ?? {};
+      const id = meta.id;
+      // A subagent or forked rollout starts with its own meta, then replays its parent's history,
+      // parent meta included. The first meta is the session; a later one is lineage, not identity.
+      if (metaSeen && lineage) continue;
       if (sessionId && id && id !== sessionId)
         throw new Error('Transcript session identity mismatch');
       sessionId ??= id;
+      metaSeen = true;
+      // Subagent and guardian threads, and `codex exec`, are driven by an agent or a script.
+      const { originator, source } = meta;
+      if (typeof originator === 'string')
+        scripted = !/^codex/i.test(originator) || /^codex_(?:exec|sdk|mcp)/.test(originator);
+      const spawn =
+        source && typeof source === 'object' && 'subagent' in source
+          ? source.subagent?.thread_spawn
+          : undefined;
+      if (source === 'exec' || (source && typeof source === 'object' && 'subagent' in source))
+        scripted = true;
+      const parent = text(spawn?.parent_thread_id) ?? text(meta.parent_thread_id);
+      const forked = text(meta.forked_from_id);
+      if (parent || forked)
+        lineage = {
+          kind: source && typeof source === 'object' && 'subagent' in source ? 'subagent' : 'fork',
+          parentSessionId: (parent ?? forked)!,
+          ...optional('agentType', text(spawn?.agent_role ?? meta.agent_role)),
+          ...optional('agentName', text(spawn?.agent_nickname ?? meta.agent_nickname)),
+          ...(Number.isInteger(spawn?.depth) ? { depth: spawn.depth } : {}),
+        };
+      const named = text(meta.model_provider)?.toLowerCase();
+      provider = named && /^[a-z0-9][a-z0-9_-]{0,63}$/.test(named) ? named : 'openai';
     }
+    if (
+      options.source === 'codex' &&
+      row.type === 'event_msg' &&
+      row.payload?.type === 'token_count' &&
+      text(row.payload.rate_limits?.plan_type)
+    )
+      subscription = true;
+    if (
+      options.source === 'claude-code' &&
+      row.quotaLimits &&
+      typeof row.quotaLimits === 'object' &&
+      text(row.quotaLimits.rateLimitType)
+    )
+      subscription = true;
     if (options.source === 'claude-code' && row.sessionId) {
       // Subagent transcripts reuse their parent's sessionId; each is its own archive.
       const id =
@@ -92,8 +182,9 @@ export function importTranscriptLines(
           : row.sessionId;
       if (sessionId && sessionId !== id) throw new Error('Mixed transcript sessions');
       sessionId = id;
+      if (row.isSidechain && typeof row.agentId === 'string')
+        lineage ??= { kind: 'subagent', parentSessionId: row.sessionId };
     }
-    const text = (value: unknown) => (typeof value === 'string' && value ? value : undefined);
     if (options.source === 'codex' && row.type === 'turn_context')
       turn = { model: text(row.payload?.model), effort: text(row.payload?.effort) };
     const producer =
@@ -102,6 +193,26 @@ export function importTranscriptLines(
         : row.type === 'assistant'
           ? { model: text(row.message?.model), effort: text(row.effort) }
           : {};
+    // A user record the person did not type: an expansion, a compaction summary, a subagent's prompt,
+    // a message from the harness, another agent or an SDK caller, or a scripted Codex session's prompt.
+    // It is kept as an event, not a user turn.
+    const written =
+      options.source === 'claude-code'
+        ? row.type === 'user' &&
+          Boolean(
+            row.isMeta ||
+              row.isCompactSummary ||
+              row.isSidechain ||
+              (row.origin && typeof row.origin === 'object'
+                ? row.origin.kind !== 'human'
+                : typeof row.entrypoint === 'string' && row.entrypoint.startsWith('sdk')),
+          )
+        : scripted && row.type === 'response_item' && row.payload?.role === 'user';
+    // User text is a user entry only when the person typed it; markers and injected blocks are events.
+    const textKind = (role: 'user' | 'assistant', content: unknown) =>
+      role === 'user' && (written || typeof content !== 'string' || !typedPrompt(content))
+        ? 'event'
+        : role;
     const timestamp = typeof row.timestamp === 'number' ? row.timestamp : Date.parse(row.timestamp);
     const add = (kind: ArchiveEntry['kind'], content: unknown, suffix: string, callId?: string) => {
       if (typeof content !== 'string' || !content.length) return;
@@ -118,10 +229,10 @@ export function importTranscriptLines(
           'Supported transcript content exceeds the archive size limit; no archive imported',
         );
       seen.set(id, identity);
-      // Claude Code marks expanded commands and caveats as meta: a title only when nothing was typed.
-      if (kind === 'user' && !prompt && !row.isCompactSummary) {
-        if (!row.isMeta) prompt = typedPrompt(content);
-        else metaPrompt ??= typedPrompt(content);
+      // A prompt someone else wrote (an expansion, a subagent's task) titles the session only when nothing was typed.
+      if (!prompt && !row.isCompactSummary) {
+        if (kind === 'user') prompt = typedPrompt(content);
+        else if (kind === 'event' && written) metaPrompt ??= typedPrompt(content);
       }
       entries.push({
         id,
@@ -139,12 +250,16 @@ export function importTranscriptLines(
       });
     };
     if (options.source === 'codex') {
-      if (row.type === 'response_item') {
+      // Codex records the person stopping a turn as its own event; Claude Code writes this marker.
+      if (row.type === 'event_msg' && row.payload?.type === 'turn_aborted') {
+        if (row.payload.reason === 'interrupted')
+          add('event', '[Request interrupted by user]', 'aborted');
+      } else if (row.type === 'response_item') {
         const p = row.payload ?? {};
         if (p.type === 'message' && ['user', 'assistant'].includes(p.role)) {
           for (const [i, block] of (p.content ?? []).entries()) {
             if (['input_text', 'output_text', 'text'].includes(block.type))
-              add(p.role, block.text, `text-${i}`);
+              add(textKind(p.role, block.text), block.text, `text-${i}`);
             else omissions.add('Non-text message content is not included');
           }
         } else if (['function_call', 'custom_tool_call'].includes(p.type)) {
@@ -181,10 +296,10 @@ export function importTranscriptLines(
       }
     } else if (['user', 'assistant'].includes(row.type) && row.message) {
       const blocks = row.message.content;
-      if (typeof blocks === 'string') add(row.type, blocks, 'text');
+      if (typeof blocks === 'string') add(textKind(row.type, blocks), blocks, 'text');
       else if (Array.isArray(blocks))
         for (const [i, block] of blocks.entries()) {
-          if (block.type === 'text') add(row.type, block.text, `text-${i}`);
+          if (block.type === 'text') add(textKind(row.type, block.text), block.text, `text-${i}`);
           else if (block.type === 'tool_use')
             add(
               'tool-call',
@@ -221,6 +336,12 @@ export function importTranscriptLines(
     sessionId,
     title,
     projectId: options.projectId,
+    runtime: {
+      provider: provider ?? 'openai',
+      accessPath: subscription ? 'subscription' : 'unknown',
+      ...(subscription ? { evidence: 'transcript' } : {}),
+    },
+    ...(lineage ? { lineage } : {}),
     tags: [],
     capturedAt: Date.now(),
     coverage: {