@tangle-network/harness-sessions 0.0.0-stage → 0.1.0

package/dist/schema.d.ts

@@ -0,0 +1,270 @@
+/**
+ * The normalized form of one harness session, and the store layouts every harness declares.
+ *
+ * Each coding-agent harness persists its own native session: Claude Code and Pi append JSONL,
+ * Codex appends a rollout JSONL, OpenCode writes SQLite. Every consumer that needs to know what
+ * happened in a turn reads it through this one shape, so a count, a served model or an ending
+ * error means the same thing in the sidecar, the Discovery gate, agent-eval, agent-record and the
+ * blog.
+ */
+/** One native session format. The id names the harness family and the on-disk layout. */
+export type SessionFormatId = 'claude-code.projects-jsonl' | 'codex.rollout-jsonl' | 'opencode.sqlite' | 'pi.session-jsonl' | 'kimi.session-dir' | 'factory.session-jsonl' | 'gemini.chat-json' | 'amp.thread-json' | 'forge.sqlite' | 'hermes.state-sqlite' | 'prime.session-jsonl' | 'openclaw.session-jsonl';
+/**
+ * Where a harness keeps its sessions, relative to the HOME it ran with. The sidecar's harness
+ * session contract imports these declarations; it does not keep a second copy.
+ */
+export interface NativeSessionStore {
+    /** Relative to the execution's private runtime HOME. Normalized, never absolute, never `..`. */
+    root: string;
+    /** Globs under `root` that hold one session. `{id}` is replaced by the native session id. */
+    files: readonly string[];
+    /** How the harness writes. This decides how a copy is taken while the harness runs. */
+    write: 'jsonl-append' | 'json-rewrite' | 'sqlite-wal';
+    /** True when one store holds every session in the HOME (opencode.db). Readers select by id. */
+    shared: boolean;
+    format: SessionFormatId;
+}
+/** Where a format's served-model, usage and ending-error evidence comes from. */
+export interface SessionEvidenceSources {
+    /** `none`: the harness records no model at all (Kimi's wire log); served models stay empty. */
+    servedModel: 'provider-response' | 'session-record' | 'turn-context' | 'none';
+    usage: 'per-response' | 'cumulative' | 'session-total';
+    endingError: 'session-record' | 'none';
+}
+export interface TokenUsage {
+    /**
+     * Prompt tokens that were neither read from nor written to a provider cache. Cache reads and
+     * cache writes are counted in their own fields and never inside `input`, so every field can be
+     * priced at its own rate. A harness that reports an inclusive input (Codex) is converted.
+     */
+    input: number | null;
+    output: number | null;
+    /** Reasoning tokens as the harness recorded them; providers count them inside `output`. */
+    reasoning: number | null;
+    cacheRead: number | null;
+    cacheWrite: number | null;
+}
+export interface SessionError {
+    /** The harness's own classification: `api-error`, `stream_error`, a provider error name. */
+    kind: string;
+    message: string;
+    /** The provider's HTTP status when the harness recorded it. */
+    httpStatus: number | null;
+    at: string | null;
+}
+export type Part = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'reasoning';
+    text: string;
+    redacted: boolean;
+} | {
+    type: 'tool-call';
+    toolCallId: string;
+} | {
+    type: 'tool-result';
+    toolCallId: string;
+} | {
+    type: 'attachment';
+    mediaType: string;
+    ref: string;
+};
+export interface SessionMessage {
+    id: string;
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    /**
+     * Who produced the message. `injected` is text the harness or the runtime added to the
+     * conversation (environment context, instructions, error notices), not the human's prompt.
+     */
+    actor: 'human' | 'agent' | 'subagent-spawn' | 'injected' | 'tool-result';
+    at: string | null;
+    /** The model call that produced an assistant message; null for every other message. */
+    modelCallId: string | null;
+    parts: Part[];
+}
+export interface SessionToolCall {
+    id: string;
+    name: string;
+    /** The arguments as structured data when the harness recorded JSON, otherwise the raw text. */
+    input: unknown;
+    /** The arguments exactly as the harness recorded them when it recorded text. */
+    inputText: string | null;
+    result: {
+        output: unknown;
+        text: string | null;
+        isError: boolean;
+        at: string | null;
+        /** The harness's own structured result (Claude Code `toolUseResult`, Pi `details`, OpenCode `metadata`). */
+        details: unknown;
+    } | null;
+    status: 'completed' | 'error' | 'pending' | 'interrupted';
+    startedAt: string | null;
+    endedAt: string | null;
+    messageId: string;
+}
+export interface ModelCall {
+    id: string;
+    at: string | null;
+    provider: string | null;
+    /** The model that answered, from the provider response or the session record. Never the request. */
+    servedModel: string | null;
+    /**
+     * The model the harness sent the request to, when the session records it. A failed request has
+     * no served model; this says which model it was meant for. Never counted as served.
+     */
+    requestedModel: string | null;
+    usage: TokenUsage | null;
+    costUsd: number | null;
+    stopReason: string | null;
+    error: SessionError | null;
+}
+export interface SessionEnding {
+    status: 'completed' | 'error' | 'aborted' | 'open';
+    error: SessionError | null;
+    at: string | null;
+}
+export interface SessionIntegrity {
+    sourceFiles: Array<{
+        path: string;
+        sha256: string;
+        bytes: number;
+    }>;
+    /** Records the reader could not parse. Never fatal in recover mode. */
+    unparsedRecords: number;
+    /** True when a source copy was cut short (a bounded capture kept only a prefix). */
+    truncated: boolean;
+    gaps: string[];
+}
+export interface HarnessSession {
+    schema: 'tangle.harness-session.v1';
+    harness: string;
+    format: SessionFormatId;
+    nativeSessionId: string;
+    parentNativeSessionId: string | null;
+    cwd: string | null;
+    startedAt: string | null;
+    endedAt: string | null;
+    messages: SessionMessage[];
+    toolCalls: SessionToolCall[];
+    modelCalls: ModelCall[];
+    /** `provider/model` (or the bare model when no provider is recorded) -> calls it answered. */
+    servedModels: Record<string, number>;
+    modelSource: SessionEvidenceSources['servedModel'];
+    /** Null when the harness recorded no usage at all. Never reported as zero. */
+    usage: TokenUsage | null;
+    ending: SessionEnding;
+    children: Array<{
+        nativeSessionId: string;
+        toolCallId: string | null;
+    }>;
+    integrity: SessionIntegrity;
+}
+/** What `summarize` keeps: counts and the facts a gate needs, in constant memory. */
+export interface SessionSummary {
+    harness: string;
+    format: SessionFormatId;
+    nativeSessionId: string;
+    parentNativeSessionId: string | null;
+    modelCalls: number;
+    /** Assistant messages the agent produced. */
+    replies: number;
+    toolCalls: number;
+    servedModels: Record<string, number>;
+    /** The served-model key (`provider/model`) of the last model call that a model answered. */
+    lastServedModel: string | null;
+    modelSource: HarnessSession['modelSource'];
+    usage: TokenUsage | null;
+    ending: SessionEnding;
+    unparsedRecords: number;
+    bytes: number;
+    truncated: boolean;
+    startedAt: string | null;
+    endedAt: string | null;
+}
+/** One discovered session, before it is read. */
+export interface SessionRef {
+    harness: string;
+    format: SessionFormatId;
+    nativeSessionId: string;
+    /** The session's primary file (the JSONL, or the SQLite store for a shared store). */
+    path: string;
+    /** Every file whose bytes the read depends on, including subagent files and SQLite siblings. */
+    files: readonly string[];
+    /** The HOME the session was found under, when it was located through a store. */
+    home: string | null;
+    cwd: string | null;
+    mtimeMs: number;
+    parentNativeSessionId: string | null;
+    /** True when the copy this ref points at is a bounded prefix of the session. */
+    truncated?: boolean;
+}
+export interface LocateOptions {
+    nativeSessionId?: string;
+    /** Sessions whose recorded cwd equals or starts with this path. */
+    cwd?: string;
+    /** Sessions modified at or after this epoch ms. */
+    sinceMs?: number;
+}
+export interface ReadOptions {
+    signal?: AbortSignal;
+    /** `recover` (default) counts unparsable records; `strict` throws on the first one. */
+    corruption?: 'recover' | 'strict';
+}
+export interface HarnessSessionReader {
+    harness: string;
+    aliases: readonly string[];
+    formats: readonly SessionFormatId[];
+    stores: readonly NativeSessionStore[];
+    /**
+     * Globs under the first store's root: the file this reader folds for one session, and for a
+     * harness that writes each subagent's transcript separately, those files.
+     */
+    globs: {
+        session: string;
+        children?: string;
+    };
+    evidence: SessionEvidenceSources;
+    locate(home: string, opts?: LocateOptions): Promise<SessionRef[]>;
+    read(ref: SessionRef, opts?: ReadOptions): Promise<HarnessSession>;
+    /** Streams the session in constant memory with respect to message and tool-output size. */
+    summarize(ref: SessionRef, opts?: Pick<ReadOptions, 'signal'>): Promise<SessionSummary>;
+}
+/** One copy of a native session that the sidecar captured for an execution. */
+export interface NativeSessionCopy {
+    harness: string;
+    format: SessionFormatId;
+    executionId: string;
+    attempt: number;
+    nativeSessionId: string;
+    /** `snapshot`: taken while the harness ran. `settled`: taken after it exited, however it ended. */
+    copy: 'snapshot' | 'settled';
+    capturedAt: string;
+    /** Null where the sidecar did not observe the value at the copy point. */
+    process: {
+        pid: number | null;
+        exitedAt: string | null;
+        exitCode: number | null;
+        signal: string | null;
+    };
+    files: Array<{
+        /** Path inside the archive, relative to the archive root. */
+        path: string;
+        /** The store root the file belongs to, relative to the runtime HOME. */
+        store: string;
+        /** The file's own path relative to the runtime HOME; the sidecar archive's payload names are flat. */
+        storePath?: string;
+        sizeBytes: number;
+        sha256: string;
+        method: 'byte-prefix' | 'atomic-file' | 'sqlite-backup';
+        truncated: boolean;
+    }>;
+    complete: boolean;
+    missingReasons: string[];
+}
+/** The part of the sidecar's raw-evidence archive manifest this package reads. */
+export interface RawEvidenceArchiveManifestV2 {
+    schema: 'tangle.raw-evidence-archive.v2';
+    nativeSessions: NativeSessionCopy[];
+}
+export declare const HARNESS_SESSION_SCHEMA: 'tangle.harness-session.v1';

package/dist/schema.js

@@ -0,0 +1,10 @@
+/**
+ * The normalized form of one harness session, and the store layouts every harness declares.
+ *
+ * Each coding-agent harness persists its own native session: Claude Code and Pi append JSONL,
+ * Codex appends a rollout JSONL, OpenCode writes SQLite. Every consumer that needs to know what
+ * happened in a turn reads it through this one shape, so a count, a served model or an ending
+ * error means the same thing in the sidecar, the Discovery gate, agent-eval, agent-record and the
+ * blog.
+ */
+export const HARNESS_SESSION_SCHEMA = 'tangle.harness-session.v1';

package/dist/source.d.ts

@@ -0,0 +1,67 @@
+import type { DatabaseSync } from 'node:sqlite';
+/** What one source file contributed to a read: its identity and what could not be parsed. */
+export interface SourceStats {
+    path: string;
+    sha256: string;
+    bytes: number;
+    unparsed: number;
+    /** The file ended without a newline and its last bytes were not a complete record. */
+    tornTail: boolean;
+    /** The line number (1-based) of the record most recently yielded. */
+    line: number;
+    /** Line numbers of the first unparsable lines (at most 50), for the gaps a reader reports. */
+    unparsedLines?: number[];
+}
+/** Records to fold, with the stats of the bytes they came from. */
+export interface RecordSource {
+    stats: SourceStats;
+    records: AsyncIterable<Record<string, unknown>>;
+}
+export declare class SessionParseError extends Error {
+    readonly path: string;
+    readonly line: number;
+    constructor(path: string, line: number, reason: string);
+}
+/**
+ * Streams the JSON records of one append-only JSONL file. Each record is parsed and yielded in
+ * order; the whole file is hashed as it is read. An unparsable line is counted (or thrown in
+ * strict mode). A final line without a newline that does not parse is a record the harness was
+ * still writing when the copy was taken, so it is reported as a torn tail rather than corruption.
+ */
+export declare function readJsonlRecords(path: string, stats: SourceStats, options?: {
+    strict?: boolean;
+    signal?: AbortSignal;
+}): AsyncGenerator<Record<string, unknown>>;
+export declare function newSourceStats(path: string): SourceStats;
+/** The records of a JSONL file, streamed. */
+export declare function fileRecords(path: string, options?: {
+    strict?: boolean;
+    signal?: AbortSignal;
+}): RecordSource;
+/** Stats for bytes already in memory. */
+export declare function memoryStats(label: string, text?: string): SourceStats;
+/** The records of JSONL text already in memory (a retained copy, a blob), read synchronously. */
+export declare function textRecordsSync(text: string, stats: SourceStats, options?: {
+    strict?: boolean;
+}): Generator<Record<string, unknown>>;
+/** Records a caller already parsed (one per line, in order). Non-objects count as unparsed. */
+export declare function arrayRecordsSync(values: readonly unknown[], stats: SourceStats): Generator<Record<string, unknown>>;
+/** Hash a file without parsing it. */
+export declare function hashFile(path: string): Promise<{
+    sha256: string;
+    bytes: number;
+}>;
+/**
+ * Run `use` against a private copy of a SQLite store. Opening a live store can checkpoint its
+ * write-ahead log and change the bytes a capture is keeping, so the store and its -wal and -shm
+ * siblings are copied first and only the copy is opened. `use` is synchronous so no other read can
+ * replace the copy while it runs.
+ */
+export declare function withSqliteCopy<T>(path: string, use: (db: DatabaseSync, sources: Array<{
+    path: string;
+    sha256: string;
+    bytes: number;
+}>) => T): Promise<T>;
+/** Remove the private store copy now instead of at process exit. */
+export declare function releaseSqliteCopy(): void;
+export declare function isMissing(error: unknown): boolean;

package/dist/source.js

@@ -0,0 +1,254 @@
+import { createHash } from 'node:crypto';
+import { createReadStream, rmSync } from 'node:fs';
+import { copyFile, mkdtemp, stat } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+const MAX_UNPARSED_LINES = 50;
+function noteUnparsed(stats, line) {
+    stats.unparsed += 1;
+    stats.unparsedLines ??= [];
+    if (stats.unparsedLines.length < MAX_UNPARSED_LINES)
+        stats.unparsedLines.push(line);
+}
+export class SessionParseError extends Error {
+    path;
+    line;
+    constructor(path, line, reason) {
+        super(`${path}:${line}: ${reason}`);
+        this.path = path;
+        this.line = line;
+        this.name = 'SessionParseError';
+    }
+}
+const NEWLINE = 0x0a;
+/**
+ * Streams the JSON records of one append-only JSONL file. Each record is parsed and yielded in
+ * order; the whole file is hashed as it is read. An unparsable line is counted (or thrown in
+ * strict mode). A final line without a newline that does not parse is a record the harness was
+ * still writing when the copy was taken, so it is reported as a torn tail rather than corruption.
+ */
+export async function* readJsonlRecords(path, stats, options = {}) {
+    const hash = createHash('sha256');
+    let pending = [];
+    let pendingBytes = 0;
+    let lineNumber = 0;
+    const parse = (bytes, terminated) => {
+        lineNumber += 1;
+        const text = bytes.toString('utf8').replace(/\r$/u, '');
+        if (text.trim().length === 0)
+            return undefined;
+        let value;
+        try {
+            value = JSON.parse(text);
+        }
+        catch {
+            if (!terminated) {
+                stats.tornTail = true;
+                return undefined;
+            }
+            if (options.strict)
+                throw new SessionParseError(path, lineNumber, 'malformed JSON');
+            noteUnparsed(stats, lineNumber);
+            return undefined;
+        }
+        if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+            if (options.strict)
+                throw new SessionParseError(path, lineNumber, 'record is not a JSON object');
+            noteUnparsed(stats, lineNumber);
+            return undefined;
+        }
+        return value;
+    };
+    const stream = createReadStream(path, { highWaterMark: 1 << 20, signal: options.signal });
+    for await (const chunk of stream) {
+        hash.update(chunk);
+        stats.bytes += chunk.length;
+        let start = 0;
+        for (;;) {
+            const index = chunk.indexOf(NEWLINE, start);
+            if (index === -1)
+                break;
+            let line;
+            if (pendingBytes > 0) {
+                pending.push(chunk.subarray(start, index));
+                line = Buffer.concat(pending);
+                pending = [];
+                pendingBytes = 0;
+            }
+            else {
+                line = chunk.subarray(start, index);
+            }
+            const record = parse(line, true);
+            if (record !== undefined) {
+                stats.line = lineNumber;
+                yield record;
+            }
+            start = index + 1;
+        }
+        if (start < chunk.length) {
+            pending.push(chunk.subarray(start));
+            pendingBytes += chunk.length - start;
+        }
+    }
+    if (pendingBytes > 0) {
+        const record = parse(Buffer.concat(pending), false);
+        if (record !== undefined) {
+            stats.line = lineNumber;
+            yield record;
+        }
+    }
+    stats.sha256 = `sha256:${hash.digest('hex')}`;
+}
+export function newSourceStats(path) {
+    return { path, sha256: '', bytes: 0, unparsed: 0, tornTail: false, line: 0 };
+}
+/** The records of a JSONL file, streamed. */
+export function fileRecords(path, options = {}) {
+    const stats = newSourceStats(path);
+    return { stats, records: readJsonlRecords(path, stats, options) };
+}
+/** Stats for bytes already in memory. */
+export function memoryStats(label, text) {
+    if (text === undefined)
+        return { path: label, sha256: '', bytes: 0, unparsed: 0, tornTail: false, line: 0 };
+    const bytes = Buffer.from(text, 'utf8');
+    return { path: label, sha256: `sha256:${createHash('sha256').update(bytes).digest('hex')}`, bytes: bytes.length, unparsed: 0, tornTail: false, line: 0 };
+}
+/** The records of JSONL text already in memory (a retained copy, a blob), read synchronously. */
+export function* textRecordsSync(text, stats, options = {}) {
+    const lines = text.split('\n');
+    for (const [index, raw] of lines.entries()) {
+        const line = raw.replace(/\r$/u, '');
+        if (line.trim().length === 0)
+            continue;
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch {
+            if (index === lines.length - 1) {
+                stats.tornTail = true;
+                continue;
+            }
+            if (options.strict)
+                throw new SessionParseError(stats.path, index + 1, 'malformed JSON');
+            noteUnparsed(stats, index + 1);
+            continue;
+        }
+        if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+            if (options.strict)
+                throw new SessionParseError(stats.path, index + 1, 'record is not a JSON object');
+            noteUnparsed(stats, index + 1);
+            continue;
+        }
+        stats.line = index + 1;
+        yield value;
+    }
+}
+/** Records a caller already parsed (one per line, in order). Non-objects count as unparsed. */
+export function* arrayRecordsSync(values, stats) {
+    for (const [index, value] of values.entries()) {
+        if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+            noteUnparsed(stats, index + 1);
+            continue;
+        }
+        stats.line = index + 1;
+        yield value;
+    }
+}
+/** Hash a file without parsing it. */
+export async function hashFile(path) {
+    const hash = createHash('sha256');
+    let bytes = 0;
+    for await (const chunk of createReadStream(path)) {
+        hash.update(chunk);
+        bytes += chunk.length;
+    }
+    return { sha256: `sha256:${hash.digest('hex')}`, bytes };
+}
+// `node:sqlite` is loaded through `createRequire`: bundlers rewrite a dynamic `import()` of a
+// `node:` builtin under some targets, and a require obtained this way is not analyzable by them.
+function loadSqlite() {
+    const nodeRequire = createRequire(import.meta.url);
+    return nodeRequire('node:sqlite');
+}
+// One private copy is kept per process: reading every session of one store (a 4 GB opencode.db
+// holding 26 sessions) copies it once, not once per session. It is replaced when a different
+// store, or a store that changed, is read, and removed when the process exits.
+let current = null;
+function dropCopy() {
+    if (current === null)
+        return;
+    try {
+        current.db.close();
+    }
+    catch {
+        // already closed
+    }
+    rmSync(current.dir, { recursive: true, force: true });
+    current = null;
+}
+process.once('exit', dropCopy);
+async function storeKey(path) {
+    const parts = [];
+    for (const suffix of ['', '-wal']) {
+        try {
+            const s = await stat(`${path}${suffix}`);
+            parts.push(`${s.dev}:${s.ino}:${s.size}:${s.mtimeMs}`);
+        }
+        catch (error) {
+            if (suffix === '' || !isMissing(error))
+                throw error;
+            parts.push('-');
+        }
+    }
+    return `${path}|${parts.join('|')}`;
+}
+/**
+ * Run `use` against a private copy of a SQLite store. Opening a live store can checkpoint its
+ * write-ahead log and change the bytes a capture is keeping, so the store and its -wal and -shm
+ * siblings are copied first and only the copy is opened. `use` is synchronous so no other read can
+ * replace the copy while it runs.
+ */
+export async function withSqliteCopy(path, use) {
+    const key = await storeKey(path);
+    if (current?.key !== key) {
+        const { DatabaseSync } = loadSqlite();
+        const dir = await mkdtemp(join(tmpdir(), 'harness-sessions-sqlite-'));
+        try {
+            const sources = [];
+            for (const suffix of ['', '-wal', '-shm']) {
+                const copy = join(dir, `store.db${suffix}`);
+                try {
+                    await copyFile(`${path}${suffix}`, copy);
+                }
+                catch (error) {
+                    if (suffix === '' || !isMissing(error))
+                        throw error;
+                    continue;
+                }
+                // The shared-memory index is rebuilt from the WAL; only the store and its log carry data.
+                if (suffix !== '-shm')
+                    sources.push({ path: `${path}${suffix}`, ...(await hashFile(copy)) });
+            }
+            // Opened writable so SQLite replays the copied write-ahead log into the private copy.
+            const db = new DatabaseSync(join(dir, 'store.db'));
+            dropCopy();
+            current = { key, dir, db, sources };
+        }
+        catch (error) {
+            rmSync(dir, { recursive: true, force: true });
+            throw error;
+        }
+    }
+    return use(current.db, current.sources);
+}
+/** Remove the private store copy now instead of at process exit. */
+export function releaseSqliteCopy() {
+    dropCopy();
+}
+export function isMissing(error) {
+    const code = error?.code;
+    return code === 'ENOENT' || code === 'ENOTDIR';
+}

package/dist/stores.d.ts

@@ -0,0 +1,7 @@
+import type { NativeSessionStore } from './schema.js';
+export { assertStoreRoot, EVIDENCE, SESSION_FORMAT_IDS, STORES, storeGlob } from './catalog.js';
+/** Every file under `dir`, as paths relative to it with `/` separators. Missing dirs yield none. */
+export declare function walkFiles(dir: string, signal?: AbortSignal): Promise<string[]>;
+/** Files under `home` that one store glob matches, as absolute paths. */
+export declare function storeFiles(home: string, store: NativeSessionStore, glob: string, nativeSessionId?: string): Promise<string[]>;
+export declare function mtimeMs(path: string): Promise<number>;

package/dist/stores.js

@@ -0,0 +1,46 @@
+import { readdir, stat } from 'node:fs/promises';
+import { join, relative, sep } from 'node:path';
+import { storeGlob } from './catalog.js';
+import { isMissing } from './source.js';
+export { assertStoreRoot, EVIDENCE, SESSION_FORMAT_IDS, STORES, storeGlob } from './catalog.js';
+/** Every file under `dir`, as paths relative to it with `/` separators. Missing dirs yield none. */
+export async function walkFiles(dir, signal) {
+    const out = [];
+    const visit = async (current) => {
+        signal?.throwIfAborted();
+        let entries;
+        try {
+            entries = await readdir(current, { withFileTypes: true });
+        }
+        catch (error) {
+            if (isMissing(error))
+                return;
+            throw error;
+        }
+        for (const entry of entries) {
+            const path = join(current, entry.name);
+            if (entry.isDirectory())
+                await visit(path);
+            else if (entry.isFile())
+                out.push(relative(dir, path).split(sep).join('/'));
+        }
+    };
+    await visit(dir);
+    return out.sort();
+}
+/** Files under `home` that one store glob matches, as absolute paths. */
+export async function storeFiles(home, store, glob, nativeSessionId) {
+    const root = join(home, store.root);
+    const pattern = storeGlob(glob, nativeSessionId);
+    return (await walkFiles(root)).filter((path) => pattern.test(path)).map((path) => join(root, path));
+}
+export async function mtimeMs(path) {
+    try {
+        return (await stat(path)).mtimeMs;
+    }
+    catch (error) {
+        if (isMissing(error))
+            return 0;
+        throw error;
+    }
+}