engineering-memory 1.10.2 → 1.10.4

package/runtime/dist/src/runtime/api-client.js

@@ -20,7 +20,10 @@ export const backendRecoveryOperationNames = [
     'session.resume',
     'context.refresh',
     'context.prepare_change',
+    'memory.sync_status',
+    'project.onboarding_status',
     'memory.query',
+    'memory.catalog',
     'memory.history',
     'memory.propose_revision',
     'memory.list_proposals',

package/runtime/dist/src/runtime/bridge-service.js

@@ -1,11 +1,15 @@
 import { randomUUID } from 'node:crypto';
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { lstat, readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { SourceSnapshot } from '../git/source-snapshot.js';
+import { ProjectIntake } from '../project/project-intake.js';
+import { canonicalPath } from '../utilities/files.js';
 import { minimatch } from 'minimatch';
 import { endpoints } from '../config.js';
 import { sha256, stableStringify } from '../utilities/hash.js';
 import { ApiResponseError, BackendUnavailableError, } from './api-client.js';
 import { assertSafeToPersist, normalizeRepositoryPaths } from './offline-outbox.js';
+import { principalFingerprint } from './principal-state.js';
 import { BridgeRecoveryError } from './recovery-error.js';
 export const validationIds = [
     'format',
@@ -32,6 +36,91 @@ export class BridgeService {
         this.dependencies = dependencies;
         this.deferDeliveries = dependencies.deferDeliveries ?? true;
     }
+    async questionnaireAsk(input) {
+        const scope = await this.questionnaireScope(input.repoRoot, input.preparation);
+        const { repoRoot: _repoRoot, preparation: _preparation, ...definition } = input;
+        return await this.dependencies.questionnaires.ask(scope, definition);
+    }
+    async questionnaireResume(input) {
+        const scope = await this.questionnaireScope(input.repoRoot, input.preparation);
+        const record = await this.dependencies.questionnaires.get(scope, input.questionnaireId);
+        if (!record)
+            throw refuse('No questionnaire exists for this account and repository binding.', 'session.entry');
+        return record;
+    }
+    async questionnaireWithdraw(input) {
+        const scope = await this.questionnaireScope(input.repoRoot, input.preparation);
+        return this.dependencies.questionnaires.withdraw(scope, input.questionnaireId);
+    }
+    async questionnaireAccept(input) {
+        const scope = await this.questionnaireScope(input.repoRoot, input.preparation);
+        if (stableStringify(scope) !== stableStringify(input.scope)) {
+            throw refuse('The account or repository binding changed while the questionnaire was open.', 'session.entry');
+        }
+        return await this.dependencies.questionnaires.accept(scope, input.questionnaireId, input.requestKey, input.answer);
+    }
+    async questionnaireScope(repoRoot, preparation = false) {
+        await this.dependencies.principalState?.ensure();
+        const accessToken = await this.dependencies.credentials.get('access-token');
+        const target = await canonicalPath(repoRoot ?? process.cwd());
+        let lookup = target;
+        if (preparation) {
+            for (;;) {
+                try {
+                    await lstat(lookup);
+                    break;
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT' || dirname(lookup) === lookup)
+                        throw error;
+                    lookup = dirname(lookup);
+                }
+            }
+        }
+        let repository;
+        try {
+            repository = await this.dependencies.repositories.resolve(lookup);
+        }
+        catch (error) {
+            if (!preparation ||
+                !(error instanceof Error) ||
+                !error.message.startsWith('Not a Git repository:'))
+                throw error;
+        }
+        const decision = repository
+            ? await this.dependencies.repositoryDecisions.load(repository.repoFingerprint)
+            : null;
+        if (decision?.state === 'disabled')
+            throw refuse('Engineering Memory is disabled in this repository.', 'session.entry');
+        if (preparation && repository?.projectId)
+            throw refuse('This target is already inside a bound project. Use its normal questionnaire scope.', 'session.entry');
+        const principalHash = accessToken ? principalFingerprint(accessToken) : sha256('anonymous');
+        const currentCredential = await this.dependencies.credentials.get('access-token');
+        if (principalHash !==
+            (currentCredential ? principalFingerprint(currentCredential) : sha256('anonymous'))) {
+            throw refuse('The account changed while the questionnaire scope was being resolved.', 'session.entry');
+        }
+        return {
+            principalHash,
+            repoFingerprint: preparation
+                ? sha256('preparation:' + (process.platform === 'win32' ? target.toLowerCase() : target))
+                : repository.repoFingerprint,
+            projectId: preparation ? null : repository.projectId,
+        };
+    }
+    async pendingQuestionnaires(repoRoot) {
+        const scope = await this.questionnaireScope(repoRoot);
+        return (await this.dependencies.questionnaires.pending(scope)).map((record) => ({
+            questionnaireId: record.questionnaireId,
+            message: record.message,
+            options: record.options,
+            allowFreeText: record.allowFreeText,
+            ...(record.textField ? { textField: record.textField } : {}),
+            createdAt: record.createdAt,
+            status: record.status,
+            nextAction: 'Call questionnaire.resume with this questionnaireId. No answer, elapsed time, dismissal or interruption is consent. If the user explicitly cancels this decision, call questionnaire.withdraw. Unrelated pending decisions never block independently authorized work.',
+        }));
+    }
     deliverInBackground() {
         if (!this.deferDeliveries)
             return;
@@ -185,6 +274,23 @@ export class BridgeService {
     async sessionResume(input) {
         return await this.execute(async () => {
             const repository = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd(), input.projectId);
+            const decision = await this.dependencies.repositoryDecisions.load(repository.repoFingerprint);
+            if (decision?.state === 'disabled') {
+                return asJsonValue({
+                    decision: 'disabled',
+                    nextAction: entryNextAction(false, 'disabled'),
+                });
+            }
+            const pendingQuestionnaires = await this.pendingQuestionnaires(repository.repoRoot);
+            const signedIn = (await this.dependencies.browserAuth.status()).authenticated;
+            if (!signedIn && pendingQuestionnaires.length > 0) {
+                return asJsonValue({
+                    authenticated: false,
+                    pendingQuestionnaires,
+                    repository: publicRepository(repository),
+                    nextAction: 'Resume only the pending sign-in questionnaire for this work. Signing in is still required before accessing project memory.',
+                });
+            }
             const authentication = await this.dependencies.browserAuth.ensureAuthenticated();
             if (authentication) {
                 return asJsonValue({ authentication, repository: publicRepository(repository) });
@@ -204,6 +310,7 @@ export class BridgeService {
                 return asJsonValue({
                     taskChoiceRequired: true,
                     requestedTaskSlug: input.taskSlug,
+                    pendingQuestionnaires,
                     liveTasks: live.map(describePointer),
                     repository: publicRepository(repository),
                 });
@@ -212,6 +319,7 @@ export class BridgeService {
                 return asJsonValue({
                     taskChoiceRequired: true,
                     requestedSessionId: input.sessionId,
+                    pendingQuestionnaires,
                     liveTasks: live.map(describePointer),
                     repository: publicRepository(repository),
                 });
@@ -219,6 +327,7 @@ export class BridgeService {
             if (!pointer && live.length > 1) {
                 return asJsonValue({
                     taskChoiceRequired: true,
+                    pendingQuestionnaires,
                     liveTasks: live.map(describePointer),
                     repository: publicRepository(repository),
                 });
@@ -227,6 +336,13 @@ export class BridgeService {
             const taskSlug = input.taskSlug ?? pointer?.taskSlug;
             const sessionId = input.sessionId ?? pointer?.sessionId;
             if (!projectId || !taskSlug || !sessionId) {
+                if (pendingQuestionnaires.length > 0) {
+                    return asJsonValue({
+                        pendingQuestionnaires,
+                        repository: publicRepository(repository),
+                        nextAction: 'Resume only the pending questionnaire for this work. Unrelated pending questions never block a separate task; continue independently authorized work.',
+                    });
+                }
                 throw refuse('This repository has no live task to resume.', 'session.bootstrap');
             }
             if ((pointer &&
@@ -240,6 +356,7 @@ export class BridgeService {
                 const recoveredClose = await this.retryCloseIntent(repository, pointer);
                 return asJsonValue({
                     backend: { close: recoveredClose },
+                    pendingQuestionnaires,
                     repository: publicRepository(repository),
                     localJournal: await this.dependencies.journal.load(projectId, taskSlug),
                     synchronization: {
@@ -411,6 +528,7 @@ export class BridgeService {
                 backend,
                 repository: publicRepository(repository),
                 localJournal,
+                pendingQuestionnaires,
                 synchronization: {
                     backendSource: responseSource,
                     backendFresh: responseSource !== 'stale_cache',
@@ -739,6 +857,264 @@ export class BridgeService {
             return await this.mutateWithOutbox('memory.propose_revision', endpoints.memoryProposeRevision, body);
         });
     }
+    async projectInspect(input) {
+        return this.execute(async () => asJsonValue(await new ProjectIntake().inspect(input.repoRoot)));
+    }
+    async onboardingChoice(input) {
+        return this.execute(async () => {
+            const scope = await this.questionnaireScope(input.repoRoot, input.preparation);
+            if (!this.dependencies.onboarding)
+                throw refuse('Update the client to persist onboarding choices.', 'session.entry');
+            if (input.choice) {
+                if (input.choice.requestKey !== input.requestKey)
+                    throw refuse('Keep the onboarding request identity unchanged.', 'session.entry');
+                const question = input.questionnaireId
+                    ? await this.dependencies.questionnaires.get(scope, input.questionnaireId)
+                    : null;
+                const digest = sha256(stableStringify(input.choice));
+                if (question?.answer?.choice !== 'approve' || !question.message.includes(digest))
+                    throw refuse('Approve the exact mode and profile through project.onboard before continuing.', 'session.entry');
+                return asJsonValue(await this.dependencies.onboarding.save(scope, input.choice));
+            }
+            return asJsonValue(await this.dependencies.onboarding.get(scope, input.requestKey));
+        });
+    }
+    async projectInitialize(input) {
+        if (input.questionnaireId !==
+            'onboard-profile-' + sha256(stableStringify(input.choice)) + '-initialize')
+            return this.execute(async () => {
+                throw refuse('Confirm Git preparation through project.initialize; a saved profile does not authorize initialization.', 'session.entry');
+            });
+        const stored = await this.onboardingChoice(input);
+        if (!stored.ok)
+            return stored;
+        return this.execute(async () => {
+            if (input.choice.mode !== 'greenfield')
+                throw refuse('Only the greenfield choice initializes Git. Use project.onboard for adoption or rework.', 'session.entry');
+            return asJsonValue({
+                ...(await new ProjectIntake().initialize(input.repoRoot)),
+                onboarding: stored.data,
+            });
+        });
+    }
+    async memorySource(input) {
+        return this.execute(async () => {
+            const repository = await this.dependencies.repositories.resolve(input.repoRoot);
+            const snapshot = new SourceSnapshot();
+            if (input.previousCommit) {
+                const history = await snapshot.history(repository.repoRoot, input.previousCommit, input.commit ?? input.ref ?? 'HEAD');
+                const paths = history.changes.changedPaths.filter((path) => !input.afterPath || Buffer.compare(Buffer.from(path), Buffer.from(input.afterPath)) > 0);
+                const limit = input.limit ?? 100;
+                const page = new Set(paths.slice(0, limit));
+                return asJsonValue({
+                    previousCommit: history.previousCommit,
+                    currentCommit: history.currentCommit,
+                    fallback: history.fallback ?? null,
+                    recentRelevantCommitIds: history.recentRelevantCommitIds,
+                    historyTruncated: history.historyTruncated,
+                    changedPaths: [...page],
+                    renamed: history.changes.renamed.filter((change) => page.has(change.from) || page.has(change.to)),
+                    added: history.changes.added.filter((path) => page.has(path)),
+                    deleted: history.changes.deleted.filter((path) => page.has(path)),
+                    nextCursor: paths.length > limit ? paths[limit - 1] : null,
+                    ...(history.fallback
+                        ? {
+                            nextAction: 'Use memory.sync_delta against the persisted previous inventory for content comparison. Missing history cannot prove no change.',
+                        }
+                        : {}),
+                });
+            }
+            if (input.path) {
+                if (!input.commit)
+                    throw refuse('Read source only at the inspection commit.', 'memory.sync_status');
+                const content = await snapshot.read(repository.repoRoot, input.commit, input.path, input.maxBytes ?? 1048576);
+                const offset = input.offset ?? 0, size = input.maxCharacters ?? 20000;
+                return asJsonValue({
+                    commit: input.commit,
+                    path: input.path,
+                    content: content.slice(offset, offset + size),
+                    offset,
+                    totalCharacters: content.length,
+                    nextOffset: offset + size < content.length ? offset + size : null,
+                });
+            }
+            const result = await snapshot.snapshot(repository.repoRoot, input.ref ?? 'HEAD');
+            const files = result.files.filter((file) => !input.afterPath ||
+                Buffer.compare(Buffer.from(file.path), Buffer.from(input.afterPath)) > 0);
+            const limit = input.limit ?? 100;
+            return asJsonValue({
+                ...result,
+                files: files.slice(0, limit),
+                totalFiles: result.files.length,
+                nextCursor: files.length > limit ? files[limit - 1].path : null,
+            });
+        });
+    }
+    async memorySyncStart(input) {
+        return this.execute(async () => {
+            const repository = await this.dependencies.repositories.resolve(input.repoRoot, input.projectId);
+            const snapshot = await new SourceSnapshot().snapshot(repository.repoRoot, input.ref ?? 'HEAD');
+            const { questionnaireId, ...confirmedInput } = input;
+            const digest = sha256(stableStringify(confirmedInput));
+            const scope = await this.questionnaireScope(input.repoRoot);
+            const question = await this.dependencies.questionnaires.get(scope, questionnaireId);
+            if (questionnaireId !== 'sync-start-' + digest ||
+                question?.answer?.choice !== 'approve' ||
+                input.ref !== snapshot.commit)
+                throw refuse('Confirm this exact mode and committed source through memory.sync_start before starting the inspection.', 'memory.sync_status');
+            const selected = await this.dependencies.client.request('/memory/onboarding/choose', {
+                method: 'POST',
+                body: cleanJson({
+                    projectId: input.projectId,
+                    requestKey: input.requestKey,
+                    mode: input.mode,
+                    profile: {},
+                    sourceCommit: snapshot.commit,
+                    reworkBehavior: input.reworkBehavior,
+                }),
+            });
+            const body = cleanJson({
+                projectId: input.projectId,
+                requestKey: input.requestKey,
+                mode: input.mode,
+                previousRunId: input.previousRunId,
+                reworkBehavior: input.reworkBehavior,
+                sourceCommit: snapshot.commit,
+                treeHash: snapshot.treeHash,
+                manifestHash: snapshot.manifestHash,
+                expectedFiles: snapshot.files.length,
+            });
+            assertSafeToPersist(body);
+            const response = await this.dependencies.client.request('/memory/sync/start', {
+                method: 'POST',
+                body,
+            });
+            const run = objectValue(response.data);
+            if (!run || typeof run.id !== 'string')
+                throw refuse('The inspection response has no run identity.', 'memory.sync_status');
+            if (run.state === 'inventory' || run.state === 'planning') {
+                for (let offset = 0; offset < snapshot.files.length; offset += 1000) {
+                    const page = cleanJson({
+                        projectId: input.projectId,
+                        runId: run.id,
+                        files: snapshot.files.slice(offset, offset + 1000),
+                    });
+                    assertSafeToPersist(page);
+                    await this.dependencies.client.request('/memory/sync/inventory', {
+                        method: 'POST',
+                        body: page,
+                    });
+                }
+                await this.dependencies.client.request('/memory/sync/inventory', {
+                    method: 'POST',
+                    body: cleanJson({ projectId: input.projectId, runId: run.id, files: [], seal: true }),
+                });
+            }
+            return asJsonValue({
+                runId: run.id,
+                onboarding: selected.data,
+                sourceCommit: snapshot.commit,
+                sourceRef: input.ref ?? 'HEAD',
+                checkedOutBranch: await this.dependencies.repositories.git.currentBranch(repository.repoRoot),
+                manifestHash: snapshot.manifestHash,
+                files: snapshot.files.length,
+                workingTreeExcluded: true,
+                nextAction: 'Read memory.source at this commit, plan semantic units across architecture, state, services, network, data, screens and flows; then seal the coverage plan.',
+            });
+        });
+    }
+    async memorySyncStatus(input) {
+        const { repoRoot, ...request } = input;
+        const result = await this.onboardingRequest('status', cleanJson(request));
+        if (!result.ok || !repoRoot || !input.runId)
+            return result;
+        return this.execute(async () => {
+            const repository = await this.dependencies.repositories.resolve(repoRoot, input.projectId);
+            const data = objectValue(result.data), run = objectValue(data?.run);
+            return asJsonValue({
+                ...data,
+                checkedOutHead: repository.git.head,
+                sourceMatchesCheckout: run?.sourceCommit === repository.git.head,
+                ...(run?.sourceCommit !== repository.git.head
+                    ? {
+                        sourceNotice: 'The checkout differs from the pinned inspection. Keep analyzing the pinned source; record a follow-up refresh for newer desired changes, and never report this source as the current checkout.',
+                    }
+                    : {}),
+            });
+        });
+    }
+    async memorySyncDelta(input) {
+        const { repoRoot, ...request } = input;
+        const delta = await this.onboardingRequest('delta', cleanJson(request));
+        if (!delta.ok || !repoRoot || input.afterId)
+            return delta;
+        const current = await this.onboardingRequest('status', cleanJson({ projectId: input.projectId, runId: input.runId, limit: 1 }));
+        if (!current.ok)
+            return current;
+        const run = objectValue(objectValue(current.data)?.run);
+        if (typeof run?.previousRunId !== 'string' || typeof run.sourceCommit !== 'string')
+            return delta;
+        const previous = await this.onboardingRequest('status', cleanJson({ projectId: input.projectId, runId: run.previousRunId, limit: 1 }));
+        if (!previous.ok)
+            return previous;
+        const prior = objectValue(objectValue(previous.data)?.run);
+        if (typeof prior?.sourceCommit !== 'string')
+            return delta;
+        const history = await this.memorySource({
+            repoRoot,
+            commit: run.sourceCommit,
+            previousCommit: prior.sourceCommit,
+            limit: 100,
+        });
+        return {
+            ok: true,
+            data: asJsonValue({
+                ...objectValue(delta.data),
+                sourceHistory: history.ok
+                    ? history.data
+                    : { unavailable: true, contentComparisonAuthoritative: true },
+            }),
+        };
+    }
+    async onboardingRequest(operation, body) {
+        return this.execute(async () => {
+            assertSafeToPersist(body);
+            const routes = {
+                status: '/memory/sync/status',
+                inventory: '/memory/sync/inventory',
+                plan: '/memory/sync/plan',
+                next: '/memory/sync/next',
+                submit: '/memory/sync/submit',
+                verify: '/memory/sync/verify',
+                reopen: '/memory/sync/reopen',
+                delta: '/memory/sync/delta',
+                catalog: '/memory/catalog',
+                read_revisions: '/memory/revisions/read',
+                review_batch: '/memory/proposals/review-batch',
+                onboarding_choose: '/memory/onboarding/choose',
+                onboarding_status: '/memory/onboarding/status',
+                rework: '/memory/onboarding/rework',
+            };
+            const response = await this.dependencies.client.request(routes[operation], {
+                method: 'POST',
+                body,
+            });
+            if (operation === 'review_batch' && Array.isArray(response.data)) {
+                const invalidatedTaskIds = [
+                    ...new Set(response.data.flatMap((item) => {
+                        const value = objectValue(item)?.invalidatedTaskIds;
+                        return Array.isArray(value)
+                            ? value.filter((id) => typeof id === 'string')
+                            : [];
+                    })),
+                ];
+                for (const id of invalidatedTaskIds)
+                    await this.dependencies.gate.invalidateTask(id);
+                await this.dependencies.activeContexts.markTasksConflict(invalidatedTaskIds, 'approved_memory_revision_requires_refresh');
+            }
+            return response.data;
+        });
+    }
     async memoryListProposals(input) {
         return await this.execute(async () => {
             const response = await this.dependencies.client.request(endpoints.memoryListProposals, { method: 'POST', body: cleanJson(input) });
@@ -1745,6 +2121,10 @@ export class BridgeService {
                 repository = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd());
             }
             catch (error) {
+                const missingTarget = error.code === 'ENOENT';
+                const outsideGit = error instanceof Error && error.message.startsWith('Not a Git repository:');
+                if (!missingTarget && !outsideGit)
+                    throw error;
                 const authenticated = authentication.authenticated === true;
                 const clonable = authenticated ? await this.clonableProjects() : [];
                 return asJsonValue({
@@ -1752,9 +2132,10 @@ export class BridgeService {
                     repository: null,
                     decision: 'none',
                     clonableProjects: clonable,
-                    nextAction: clonable.length > 0
-                        ? 'This directory is not a Git repository. Offer the listed projects and clone the one the user chooses with project.clone. Do not mention Engineering Memory otherwise.'
-                        : 'This directory is not a Git repository, so Engineering Memory has nothing to bind. Work normally and say nothing about it.',
+                    preparationAvailable: true,
+                    nextAction: !authenticated
+                        ? 'Sign in through auth.signin_browser before binding a project. Native questionnaires may use preparation:true for this target before Git exists.'
+                        : 'No Git repository is bound here. For requested project creation, inspect the selected target with project.inspect, ask greenfield/adopt/rework through questionnaire.ask with preparation:true, then project.initialize if needed and organization/project selection. Existing projects may be cloned from clonableProjects. Never create a folder, choose a mode or bind a project silently.',
                     reason: error instanceof Error ? error.message : String(error),
                 });
             }
@@ -1772,6 +2153,7 @@ export class BridgeService {
                 ? await this.actionableWorkItems(projectId)
                 : [];
             const taskSelectionRequired = liveTasks.length > 0 || workItems.length > 0;
+            const pendingQuestionnaires = state !== 'disabled' ? await this.pendingQuestionnaires(repository.repoRoot) : [];
             return asJsonValue({
                 authenticated,
                 repository: publicRepository(repository),
@@ -1780,15 +2162,18 @@ export class BridgeService {
                 liveTasks,
                 workItems,
                 taskSelectionRequired,
+                ...(state !== 'disabled' ? { pendingQuestionnaires } : {}),
                 client,
                 ...(incomplete && state === 'bound'
                     ? {
                         shippedKnowledgeWarning: 'The backend is not serving all of the knowledge this release ships. Tell the user before relying on the rules: some are missing from the running server, so a review against them is incomplete. The counts and the reason are in client.shippedKnowledge.',
                     }
                     : {}),
-                nextAction: taskSelectionRequired
-                    ? 'Present the live runs and actionable project work items, then ask which one this chat should handle. Resume only the run they choose, or bootstrap a separate run with the chosen workItemId. Another live task never blocks opening this one.'
-                    : entryNextAction(authenticated, state),
+                nextAction: pendingQuestionnaires.length > 0
+                    ? 'Resume only the pending questionnaire for this work with questionnaire.resume before taking action that depends on its answer. Unrelated pending questions never block opening a separate task. Never infer consent from a timeout, dismissal, interrupted turn or missing answer.'
+                    : taskSelectionRequired
+                        ? 'Present the live runs and actionable project work items, then ask which one this chat should handle. Resume only the run they choose, or bootstrap a separate run with the chosen workItemId. Another live task never blocks opening this one.'
+                        : entryNextAction(authenticated, state),
             });
         });
     }

package/runtime/dist/src/runtime/onboarding-store.js

@@ -0,0 +1,47 @@
+import { randomUUID } from 'node:crypto';
+import { link } from 'node:fs/promises';
+import { join } from 'node:path';
+import { assertManagedPath, readJson, removeFile, writeJson } from '../utilities/files.js';
+import { sha256, stableStringify } from '../utilities/hash.js';
+import { assertSafeToPersist } from './offline-outbox.js';
+export class OnboardingStore {
+    root;
+    constructor(stateRoot) {
+        this.root = join(stateRoot, 'onboarding-choices');
+    }
+    async get(scope, requestKey) {
+        const value = await readJson(this.path(scope, requestKey), this.root);
+        if (value && value.requestKey !== requestKey)
+            throw new Error('Invalid onboarding choice identity');
+        return value;
+    }
+    async save(scope, choice) {
+        assertSafeToPersist(choice);
+        const path = this.path(scope, choice.requestKey);
+        const temporary = `${path}.${randomUUID()}.tmp`;
+        await writeJson(temporary, choice, this.root);
+        try {
+            const target = await assertManagedPath(this.root, path, true);
+            try {
+                await link(temporary, target);
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST')
+                    throw error;
+            }
+        }
+        finally {
+            await removeFile(temporary, this.root);
+        }
+        const saved = await this.get(scope, choice.requestKey);
+        if (!saved || stableStringify(saved) !== stableStringify(choice))
+            throw new Error('This request already has a different onboarding choice. Use a new request key.');
+        return saved;
+    }
+    path(scope, requestKey) {
+        if (!/^[A-Za-z0-9_-]{1,120}$/.test(requestKey))
+            throw new Error('Invalid onboarding request key');
+        return join(this.root, sha256(stableStringify(scope)), sha256(requestKey) + '.json');
+    }
+}
+//# sourceMappingURL=onboarding-store.js.map