@agents-ensemble/core 0.21.0 → 0.22.0

package/dist/session/session-resume-store.js

@@ -1,7 +1,9 @@
 import { chmod, mkdir, readdir, readFile, rename, writeFile } from 'node:fs/promises';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, join } from 'node:path';
 import { computeAcpSpawnEnvDigest, } from '../acp/resolve-acp-spawn.js';
+import { parseIssueUrl } from '../issue/issue-ref.js';
 import { resolveEnsemblePaths } from '../ensemble-paths.js';
+import { resolveUserEnsembleRoot } from '../resolve-user-ensemble-root.js';
 export const SESSION_RESUME_STORE_VERSION = 1;
 /** @deprecated Use SESSION_RESUME_STORE_VERSION; supported for one release only. */
 export const SESSION_SIDECAR_VERSION = SESSION_RESUME_STORE_VERSION;
@@ -28,6 +30,13 @@ export class SessionResumeStoreNotFoundError extends Error {
         this.name = 'SessionResumeStoreNotFoundError';
     }
 }
+class InvalidSessionResumeStoreDataError extends Error {
+    constructor(path, reason, cause) {
+        const detail = cause instanceof Error ? `: ${cause.message}` : '';
+        super(`Invalid session resume store at ${path} (${reason})${detail}`);
+        this.name = 'InvalidSessionResumeStoreDataError';
+    }
+}
 /** @deprecated Use SessionResumeStoreNotFoundError; supported for one release only. */
 export class SessionSidecarNotFoundError extends SessionResumeStoreNotFoundError {
     code = 'SESSION_SIDECAR_NOT_FOUND';
@@ -36,8 +45,12 @@ export class SessionSidecarNotFoundError extends SessionResumeStoreNotFoundError
         this.name = 'SessionSidecarNotFoundError';
     }
 }
-export function sessionResumeStoreDir(repoRoot) {
-    return resolveEnsemblePaths({ repoRoot }).sessionsDir;
+const SESSION_RESUME_STORE_PAGE_MAX_LIMIT = 500;
+const SESSION_RESUME_STORE_PAGE_CURSOR_VERSION = 1;
+/** Return the canonical user-store directory for an Issue repository. */
+export function sessionResumeStoreDir(input) {
+    return resolveEnsemblePaths({ repoRoot: input.repoRoot })
+        .canonicalRepoSessionsDir(input.issueUrl);
 }
 export function legacySessionResumeStoreDir(repoRoot) {
     return resolveEnsemblePaths({ repoRoot }).legacySessionsDir;
@@ -47,30 +60,47 @@ export function legacySessionResumeStorePath(options) {
         repoRoot: options.repoRoot,
     }).legacySessionResumeStorePath(options.conductorAgentId);
 }
+/** Return the canonical user-store path; an Issue URL is required for identity. */
 export function sessionResumeStorePath(options) {
-    return resolveEnsemblePaths({
-        repoRoot: options.repoRoot,
-    }).sessionResumeStorePath(options.conductorAgentId);
+    return canonicalSessionResumeStorePath(options);
+}
+export function canonicalSessionResumeStorePath(input) {
+    return resolveEnsemblePaths({ repoRoot: input.repoRoot })
+        .canonicalSessionResumeStorePath(input.issueUrl, input.conductorAgentId);
 }
 export async function loadSessionResumeStore(path) {
     const loaded = await readSessionResumeStore(path);
     return loaded?.resumeStore;
 }
 async function readSessionResumeStore(path) {
+    let raw;
     try {
-        const raw = await readFile(path, 'utf8');
-        const value = JSON.parse(raw);
-        return {
-            resumeStore: parseSessionResumeStore(value),
-            hasLegacyAcpSpawnEnv: containsLegacyAcpSpawnEnv(value),
-            rawValue: value,
-        };
+        raw = await readFile(path, 'utf8');
     }
     catch (error) {
         if (isEnoent(error))
             return undefined;
         throw error;
     }
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new InvalidSessionResumeStoreDataError(path, 'invalid JSON', error);
+    }
+    let resumeStore;
+    try {
+        resumeStore = parseSessionResumeStore(value);
+    }
+    catch (error) {
+        throw new InvalidSessionResumeStoreDataError(path, 'invalid schema', error);
+    }
+    return {
+        resumeStore,
+        hasLegacyAcpSpawnEnv: containsLegacyAcpSpawnEnv(value),
+        rawValue: value,
+    };
 }
 /** `resumeAgentId` 指定時に SessionResumeStore が無い場合は起動失敗とする。 */
 export async function requireSessionResumeStoreForResume(input) {
@@ -78,33 +108,36 @@ export async function requireSessionResumeStoreForResume(input) {
     return located.resumeStore;
 }
 export async function requireLocatedSessionResumeStoreForResume(input) {
-    const locations = await listSessionResumeStoreLocations(input.repoRoot, {
-        onDuplicate: input.onDuplicate,
-    });
-    const located = locations.find((candidate) => candidate.resumeStore.conductorAgentId === input.conductorAgentId);
+    if (typeof input.issueUrl !== 'string' ||
+        !input.issueUrl.trim()) {
+        throw new Error('issueUrl is required to resume a session.');
+    }
+    const locations = await listLocatedSessionResumeStoresPage(input.repoRoot, {
+        issueUrl: input.issueUrl,
+        conductorAgentId: input.conductorAgentId,
+    }, { onDuplicate: input.onDuplicate });
+    const located = locations.sessions[0];
     if (!located) {
-        const path = sessionResumeStorePath(input);
+        const path = canonicalSessionResumeStorePath(input);
         throw new SessionResumeStoreNotFoundError(input.conductorAgentId, path);
     }
     const loaded = await readSessionResumeStore(located.path);
     if (!loaded) {
         throw new SessionResumeStoreNotFoundError(input.conductorAgentId, located.path);
     }
+    const persistedValue = loaded.hasLegacyAcpSpawnEnv
+        ? redactLegacyAcpSpawnEnv(loaded.rawValue, loaded.resumeStore)
+        : loaded.resumeStore;
+    const resumeStore = parseSessionResumeStore(persistedValue);
     if (loaded.hasLegacyAcpSpawnEnv) {
-        // Scrub pre-digest env values before resume validation can reject the
-        // session and bypass its normal first write.
-        await writeSessionResumeStoreFile(located.path, redactLegacyAcpSpawnEnv(loaded.rawValue, loaded.resumeStore));
+        // Scrub canonical data before resume validation can reject the session
+        // and bypass its normal first write.
+        await writeSessionResumeStoreFile(located.path, persistedValue);
     }
-    if (located.location === 'project-legacy') {
-        const migratedPath = sessionResumeStorePath(input);
-        await writeSessionResumeStoreFile(migratedPath, loaded.resumeStore);
-        return {
-            resumeStore: loaded.resumeStore,
-            path: migratedPath,
-            location: 'user-path-hash',
-        };
-    }
-    return { ...located, resumeStore: loaded.resumeStore };
+    return {
+        ...located,
+        resumeStore,
+    };
 }
 /** @deprecated Use requireSessionResumeStoreForResume; supported for one release only. */
 export async function requireSessionSidecarForResume(input) {
@@ -153,13 +186,142 @@ export async function listLocatedSessionResumeStores(repoRoot, options = {}) {
     return listSessionResumeStoreLocations(repoRoot, options);
 }
 export async function findSessionResumeStore(repoRoot, conductorAgentId, options = {}) {
-    return (await listLocatedSessionResumeStores(repoRoot, options)).find((candidate) => candidate.resumeStore.conductorAgentId === conductorAgentId);
+    const matches = (await listLocatedSessionResumeStores(repoRoot, options)).filter((candidate) => candidate.resumeStore.conductorAgentId === conductorAgentId);
+    if (matches.length > 1) {
+        throw new Error(`Session ${conductorAgentId} is ambiguous across saved Issues; use findSessionResumeStoreBySelector with githubRepo or issueUrl.`);
+    }
+    return matches[0];
+}
+/**
+ * List local sessions using canonical GitHub repository identity.
+ *
+ * With no limit this returns every matching local store. Supplying a limit
+ * enables keyset pagination; no GitHub API repository discovery is performed.
+ */
+export async function listLocatedSessionResumeStoresPage(repoRoot, query = {}, options = {}) {
+    const scope = resolveSessionResumeStoreScope(query);
+    const stores = (await listSessionResumeStoreLocations(repoRoot, options))
+        .filter(({ resumeStore }) => {
+        const identity = sessionIssueIdentity(resumeStore.issueUrl);
+        return ((!scope.githubRepo || identity.repository === scope.githubRepo) &&
+            (!scope.issueKey || identity.key === scope.issueKey) &&
+            (!query.conductorAgentId ||
+                resumeStore.conductorAgentId === query.conductorAgentId));
+    })
+        .sort(compareLocatedSessionResumeStores);
+    const limit = query.limit === undefined
+        ? query.cursor === undefined
+            ? undefined
+            : SESSION_RESUME_STORE_PAGE_MAX_LIMIT
+        : validateSessionResumeStorePageLimit(query.limit);
+    if (limit === undefined) {
+        return { sessions: stores, total: stores.length };
+    }
+    const cursor = query.cursor === undefined
+        ? undefined
+        : decodeSessionResumeStoreCursor(query.cursor);
+    const remaining = cursor
+        ? stores.filter((store) => compareLocatedSessionResumeStoreToCursor(store, cursor) > 0)
+        : stores;
+    const sessions = remaining.slice(0, limit);
+    const next = remaining.length > sessions.length ? sessions.at(-1) : undefined;
+    return {
+        sessions,
+        total: stores.length,
+        ...(next ? { nextCursor: encodeSessionResumeStoreCursor(next) } : {}),
+    };
+}
+/**
+ * List user-scoped canonical slug stores.
+ *
+ * This is intended for repository-independent operator tools. It does not
+ * inspect path-hash or checkout-local session data, or call GitHub.
+ */
+export async function listUserLocatedSessionResumeStoresPage(query = {}, options = {}) {
+    const userRoot = options.userEnsembleRoot ?? resolveUserEnsembleRoot();
+    const scope = resolveSessionResumeStoreScope(query);
+    const stores = (await listSessionResumeStoreLocations(userRoot, {
+        onDuplicate: options.onDuplicate,
+        userEnsembleRoot: userRoot,
+    }))
+        .filter(({ resumeStore }) => {
+        const identity = sessionIssueIdentity(resumeStore.issueUrl);
+        return ((!scope.githubRepo || identity.repository === scope.githubRepo) &&
+            (!scope.issueKey || identity.key === scope.issueKey) &&
+            (!query.conductorAgentId ||
+                resumeStore.conductorAgentId === query.conductorAgentId));
+    })
+        .sort(compareLocatedSessionResumeStores);
+    return paginateLocatedSessionResumeStores(stores, query);
+}
+export async function findUserSessionResumeStore(conductorAgentId, options = {}) {
+    const id = conductorAgentId.trim();
+    if (!id) {
+        throw new Error('conductorAgentId must be a non-empty string.');
+    }
+    const page = await listUserLocatedSessionResumeStoresPage({ conductorAgentId: id }, options);
+    if (page.sessions.length > 1) {
+        throw new Error(`Session ${id} is ambiguous across saved Issues; use a repository or Issue selector.`);
+    }
+    return page.sessions[0];
+}
+function paginateLocatedSessionResumeStores(stores, query) {
+    const limit = query.limit === undefined
+        ? query.cursor === undefined
+            ? undefined
+            : SESSION_RESUME_STORE_PAGE_MAX_LIMIT
+        : validateSessionResumeStorePageLimit(query.limit);
+    if (limit === undefined) {
+        return { sessions: stores, total: stores.length };
+    }
+    const cursor = query.cursor === undefined
+        ? undefined
+        : decodeSessionResumeStoreCursor(query.cursor);
+    const remaining = cursor
+        ? stores.filter((store) => compareLocatedSessionResumeStoreToCursor(store, cursor) > 0)
+        : stores;
+    const sessions = remaining.slice(0, limit);
+    const next = remaining.length > sessions.length ? sessions.at(-1) : undefined;
+    return {
+        sessions,
+        total: stores.length,
+        ...(next ? { nextCursor: encodeSessionResumeStoreCursor(next) } : {}),
+    };
+}
+export async function listSessionResumeStoresPage(repoRoot, query = {}, options = {}) {
+    const page = await listLocatedSessionResumeStoresPage(repoRoot, query, options);
+    return {
+        sessions: page.sessions.map(({ resumeStore }) => resumeStore),
+        total: page.total,
+        ...(page.nextCursor ? { nextCursor: page.nextCursor } : {}),
+    };
+}
+/** Read a session only inside an explicit GitHub repository / Issue scope. */
+export async function findSessionResumeStoreBySelector(repoRoot, selector, options = {}) {
+    const conductorAgentId = selector.conductorAgentId.trim();
+    if (!conductorAgentId) {
+        throw new Error('conductorAgentId must be a non-empty string.');
+    }
+    const scope = resolveSessionResumeStoreScope(selector);
+    if (!scope.githubRepo && !scope.issueKey) {
+        throw new Error('Repository scope is required to read a session; pass --github-repo or --issue-url.');
+    }
+    const page = await listLocatedSessionResumeStoresPage(repoRoot, { ...selector, conductorAgentId }, options);
+    if (page.sessions.length > 1) {
+        throw new Error(`Session ${conductorAgentId} is ambiguous in this repository; specify --issue-url.`);
+    }
+    return page.sessions[0];
 }
 async function listSessionResumeStoreLocations(repoRoot, options = {}) {
-    const paths = resolveEnsemblePaths({ repoRoot });
+    const paths = resolveEnsemblePaths({
+        repoRoot,
+        ...(options.userEnsembleRoot
+            ? { userEnsembleRoot: options.userEnsembleRoot }
+            : {}),
+    });
     const candidates = [];
     const visited = new Set();
-    const readDirectory = async (dir, location, slugRoot) => {
+    const readDirectory = async (dir, location, { slugRoot, skipMalformedStoreData = false, } = {}) => {
         let entries;
         try {
             entries = await readdir(dir, { withFileTypes: true });
@@ -176,23 +338,29 @@ async function listSessionResumeStoreLocations(repoRoot, options = {}) {
             if (visited.has(path))
                 continue;
             visited.add(path);
-            const resumeStore = await loadSessionResumeStore(path);
+            let resumeStore;
+            try {
+                resumeStore = await loadSessionResumeStore(path);
+            }
+            catch (error) {
+                if (skipMalformedStoreData &&
+                    error instanceof InvalidSessionResumeStoreDataError) {
+                    continue;
+                }
+                throw error;
+            }
             if (!resumeStore)
                 continue;
             if (slugRoot &&
-                (resolve(resumeStore.repoRoot) !== paths.repoRoot ||
-                    canonicalSessionDirectory(paths, resumeStore.issueUrl) !== slugRoot)) {
+                canonicalSessionDirectory(paths, resumeStore.issueUrl) !== slugRoot) {
                 continue;
             }
             candidates.push({ resumeStore, path, location });
         }
     };
-    // The current path-hash and project-local directories are bounded and remain
-    // the discovery roots for legacy data.
-    await readDirectory(paths.sessionsDir, 'user-path-hash');
-    await readDirectory(paths.legacySessionsDir, 'project-legacy');
     // Slug stores are keyed by GitHub repository identity. Search only the
-    // host/owner/repository depth and validate repoRoot before accepting a file.
+    // host/owner/repository depth; repoRoot is execution context, not a lookup
+    // filter for canonical records.
     let hosts;
     try {
         hosts = await readdir(paths.sessionsRoot, { withFileTypes: true });
@@ -235,30 +403,29 @@ async function listSessionResumeStoreLocations(repoRoot, options = {}) {
                 if (!repository.isDirectory())
                     continue;
                 const slugRoot = join(paths.sessionsRoot, host.name, owner.name, repository.name);
-                await readDirectory(slugRoot, 'canonical-slug', slugRoot);
+                await readDirectory(slugRoot, 'canonical-slug', { slugRoot });
             }
         }
     }
-    const byAgentId = new Map();
+    const bySession = new Map();
     for (const candidate of candidates) {
-        const matching = byAgentId.get(candidate.resumeStore.conductorAgentId) ?? [];
+        const sessionKey = JSON.stringify([
+            sessionIssueIdentity(candidate.resumeStore.issueUrl).key,
+            candidate.resumeStore.conductorAgentId,
+        ]);
+        const matching = bySession.get(sessionKey) ?? [];
         matching.push(candidate);
-        byAgentId.set(candidate.resumeStore.conductorAgentId, matching);
+        bySession.set(sessionKey, matching);
     }
-    const locationPriority = {
-        'canonical-slug': 0,
-        'user-path-hash': 1,
-        'project-legacy': 2,
-    };
     const selected = [];
-    for (const [conductorAgentId, matches] of byAgentId) {
-        matches.sort((left, right) => locationPriority[left.location] - locationPriority[right.location] ||
-            right.resumeStore.updatedAt - left.resumeStore.updatedAt);
+    for (const matches of bySession.values()) {
+        matches.sort((left, right) => right.resumeStore.updatedAt - left.resumeStore.updatedAt);
         const chosen = matches[0];
         selected.push(chosen);
         if (matches.length > 1) {
             options.onDuplicate?.({
-                conductorAgentId,
+                conductorAgentId: chosen.resumeStore.conductorAgentId,
+                issueUrl: chosen.resumeStore.issueUrl,
                 selectedPath: chosen.path,
                 selectedLocation: chosen.location,
                 candidates: matches.map((candidate) => ({
@@ -279,6 +446,102 @@ function canonicalSessionDirectory(paths, issueUrl) {
         return undefined;
     }
 }
+function resolveSessionResumeStoreScope(input) {
+    const githubRepo = input.githubRepo === undefined
+        ? undefined
+        : normalizeGitHubRepo(input.githubRepo);
+    let issue;
+    if (input.issueUrl !== undefined) {
+        parseIssueUrl(input.issueUrl);
+        issue = sessionIssueIdentity(input.issueUrl);
+    }
+    if (githubRepo !== undefined &&
+        issue !== undefined &&
+        githubRepo !== issue.repository) {
+        throw new Error('--github-repo and --issue-url refer to different GitHub repositories.');
+    }
+    return {
+        ...(githubRepo ?? issue?.repository
+            ? { githubRepo: githubRepo ?? issue?.repository }
+            : {}),
+        ...(issue ? { issueKey: issue.key } : {}),
+    };
+}
+function normalizeGitHubRepo(value) {
+    const segments = value.trim().split('/');
+    if (segments.length !== 2 ||
+        segments.some((segment) => !segment ||
+            segment === '.' ||
+            segment === '..' ||
+            !/^[A-Za-z0-9_.-]+$/u.test(segment))) {
+        throw new Error(`Invalid GitHub repository "${value}" (expected <owner>/<repo>).`);
+    }
+    return `${segments[0].toLowerCase()}/${segments[1].replace(/\.git$/iu, '').toLowerCase()}`;
+}
+function sessionIssueIdentity(issueUrl) {
+    try {
+        const issue = parseIssueUrl(issueUrl);
+        const repository = `${issue.owner.toLowerCase()}/${issue.repo.toLowerCase()}`;
+        return {
+            repository,
+            key: `${repository}#${issue.number}`,
+        };
+    }
+    catch {
+        return { repository: '', key: `invalid:${issueUrl.toLowerCase()}` };
+    }
+}
+function compareLocatedSessionResumeStores(left, right) {
+    return (right.resumeStore.updatedAt - left.resumeStore.updatedAt ||
+        sessionIssueIdentity(left.resumeStore.issueUrl).key.localeCompare(sessionIssueIdentity(right.resumeStore.issueUrl).key) ||
+        left.resumeStore.conductorAgentId.localeCompare(right.resumeStore.conductorAgentId));
+}
+function compareLocatedSessionResumeStoreToCursor(store, cursor) {
+    const resumeStore = store.resumeStore;
+    return (cursor.updatedAt - resumeStore.updatedAt ||
+        sessionIssueIdentity(resumeStore.issueUrl).key.localeCompare(cursor.issueKey) ||
+        resumeStore.conductorAgentId.localeCompare(cursor.conductorAgentId));
+}
+function validateSessionResumeStorePageLimit(limit) {
+    if (!Number.isSafeInteger(limit) ||
+        limit < 1 ||
+        limit > SESSION_RESUME_STORE_PAGE_MAX_LIMIT) {
+        throw new Error(`limit must be an integer between 1 and ${SESSION_RESUME_STORE_PAGE_MAX_LIMIT}.`);
+    }
+    return limit;
+}
+function encodeSessionResumeStoreCursor(store) {
+    const cursor = {
+        version: SESSION_RESUME_STORE_PAGE_CURSOR_VERSION,
+        updatedAt: store.resumeStore.updatedAt,
+        issueKey: sessionIssueIdentity(store.resumeStore.issueUrl).key,
+        conductorAgentId: store.resumeStore.conductorAgentId,
+    };
+    return Buffer.from(JSON.stringify(cursor), 'utf8').toString('base64url');
+}
+function decodeSessionResumeStoreCursor(value) {
+    let cursor;
+    try {
+        cursor = JSON.parse(Buffer.from(value, 'base64url').toString('utf8'));
+    }
+    catch {
+        throw new Error('Invalid session list cursor.');
+    }
+    if (!isRecord(cursor) ||
+        cursor.version !== SESSION_RESUME_STORE_PAGE_CURSOR_VERSION ||
+        typeof cursor.updatedAt !== 'number' ||
+        !Number.isFinite(cursor.updatedAt) ||
+        typeof cursor.issueKey !== 'string' ||
+        typeof cursor.conductorAgentId !== 'string') {
+        throw new Error('Invalid session list cursor.');
+    }
+    return {
+        version: cursor.version,
+        updatedAt: cursor.updatedAt,
+        issueKey: cursor.issueKey,
+        conductorAgentId: cursor.conductorAgentId,
+    };
+}
 /** @deprecated Use listSessionResumeStores; supported for one release only. */
 export const listSessionSidecars = listSessionResumeStores;
 /**
@@ -286,8 +549,12 @@ export const listSessionSidecars = listSessionResumeStores;
  * updatedAt が最も新しい SessionResumeStore を返す。
  */
 export async function findLatestSessionResumeStoreForIssue(input) {
-    const matches = (await listSessionResumeStores(input.repoRoot)).filter((resumeStore) => resumeStore.issueUrl === input.issueUrl &&
-        resumeStore.repoRoot === input.repoRoot &&
+    const issueKey = sessionIssueIdentity(input.issueUrl).key;
+    const matches = (await listLocatedSessionResumeStoresPage(input.repoRoot, {
+        issueUrl: input.issueUrl,
+    })).sessions
+        .map(({ resumeStore }) => resumeStore)
+        .filter((resumeStore) => sessionIssueIdentity(resumeStore.issueUrl).key === issueKey &&
         (resumeStore.harnessPhase ??
             harnessPhaseFromLegacyLifecycle(resumeStore.lifecycle)) !== 'exit');
     if (matches.length === 0)
@@ -311,31 +578,10 @@ export function assertSessionResumeStoreMatches(resumeStore, input) {
     if (resumeStore.conductorAgentId !== input.conductorAgentId) {
         throw new Error(`Session resume store conductorAgentId mismatch: ${resumeStore.conductorAgentId} !== ${input.conductorAgentId}`);
     }
-    if (resumeStore.issueUrl !== input.issueUrl) {
+    if (sessionIssueIdentity(resumeStore.issueUrl).key !==
+        sessionIssueIdentity(input.issueUrl).key) {
         throw new Error(`Session resume store issueUrl mismatch: ${resumeStore.issueUrl} !== ${input.issueUrl}`);
     }
-    if (resumeStore.repoRoot !== input.repoRoot) {
-        throw new Error(`Session resume store repoRoot mismatch: ${resumeStore.repoRoot} !== ${input.repoRoot}`);
-    }
-    if (input.conductorBackend !== undefined &&
-        (resumeStore.conductorBackend ?? 'cursor') !== input.conductorBackend) {
-        throw new Error(`Session resume store conductorBackend mismatch: ${resumeStore.conductorBackend ?? 'cursor'} !== ${input.conductorBackend}`);
-    }
-    if (input.mcpConfigDigest !== undefined) {
-        if (resumeStore.mcpConfigDigest === undefined) {
-            if (input.mcpConfigConfigured) {
-                throw new Error('Session resume store MCP config digest missing; cannot safely resume with MCP configuration.');
-            }
-        }
-        else if (resumeStore.mcpConfigDigest !== input.mcpConfigDigest) {
-            throw new Error(`Session resume store MCP config digest mismatch: ${resumeStore.mcpConfigDigest} !== ${input.mcpConfigDigest}`);
-        }
-    }
-    if (input.ensembleConfigDigest !== undefined &&
-        resumeStore.ensembleConfigDigest !== undefined &&
-        resumeStore.ensembleConfigDigest !== input.ensembleConfigDigest) {
-        throw new Error(`Session resume store ensemble config digest mismatch: ${resumeStore.ensembleConfigDigest} !== ${input.ensembleConfigDigest}`);
-    }
 }
 /** @deprecated Use assertSessionResumeStoreMatches; supported for one release only. */
 export const assertSessionSidecarMatches = assertSessionResumeStoreMatches;
@@ -416,6 +662,10 @@ function parseSessionResumeStore(value) {
             record.cursorBootstrapRunId.trim() === '')) {
         throw new Error('Invalid session resume store: cursorBootstrapRunId');
     }
+    if (record.cursorBootstrapComplete !== undefined &&
+        typeof record.cursorBootstrapComplete !== 'boolean') {
+        throw new Error('Invalid session resume store: cursorBootstrapComplete');
+    }
     if (record.lifecycle !== undefined &&
         record.lifecycle !== 'closed' &&
         record.lifecycle !== 'exited' &&
@@ -471,6 +721,9 @@ function parseSessionResumeStore(value) {
         ...(typeof record.cursorBootstrapRunId === 'string'
             ? { cursorBootstrapRunId: record.cursorBootstrapRunId }
             : {}),
+        ...(typeof record.cursorBootstrapComplete === 'boolean'
+            ? { cursorBootstrapComplete: record.cursorBootstrapComplete }
+            : {}),
         ...(typeof record.lazyWorkers === 'boolean'
             ? { lazyWorkers: record.lazyWorkers }
             : {}),
@@ -528,6 +781,9 @@ function parseConductorBackend(value) {
     }
     throw new Error('Invalid session resume store: conductorBackend');
 }
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
 function isEnoent(error) {
     return (typeof error === 'object' &&
         error !== null &&
@@ -588,11 +844,17 @@ function parseAcpSpawnFingerprint(raw, workerName) {
     if (!Array.isArray(record.args) || record.args.some((arg) => typeof arg !== 'string')) {
         throw new Error(`Invalid session resume store worker acpSpawn args: ${workerName}`);
     }
-    const validModelTags = ['high', 'default', 'low', 'fast'];
+    let piRuntime = undefined;
+    if (record.piRuntime === 'builtin') {
+        piRuntime = 'builtin';
+    }
+    else if (record.piRuntime !== undefined &&
+        record.piRuntime !== 'byo') {
+        throw new Error(`Invalid session resume store worker acpSpawn piRuntime: ${workerName}`);
+    }
     let modelTag;
     if (record.modelTag !== undefined) {
-        if (typeof record.modelTag !== 'string' ||
-            !validModelTags.includes(record.modelTag)) {
+        if (typeof record.modelTag !== 'string') {
             throw new Error(`Invalid session resume store worker acpSpawn modelTag: ${workerName}`);
         }
         modelTag = record.modelTag;
@@ -657,6 +919,7 @@ function parseAcpSpawnFingerprint(raw, workerName) {
         preset: record.preset,
         command: record.command,
         args: record.args,
+        ...(piRuntime !== undefined ? { piRuntime } : {}),
         ...(modelTag !== undefined ? { modelTag } : {}),
         ...(model !== undefined ? { model } : {}),
         ...(reasoning !== undefined ? { reasoning } : {}),