engineering-memory 1.10.2 → 1.10.4

package/runtime/dist/src/mcp/onboarding-tools.js

@@ -0,0 +1,663 @@
+import * as z from 'zod/v4';
+import { sha256, stableStringify } from '../utilities/hash.js';
+import { askQuestionnaire } from './questionnaire-tools.js';
+const uuid = z.string().uuid();
+const hash = z.string().regex(/^[a-f0-9]{64}$/);
+const project = { projectId: uuid };
+const run = { ...project, runId: uuid };
+const page = { afterId: uuid.optional(), limit: z.number().int().min(1).max(100).optional() };
+const repoRoot = z.string().min(1);
+const json = z.lazy(() => z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(json),
+    z.record(z.string(), json),
+]));
+const object = z.record(z.string(), json);
+const reference = z.object({
+    proposalId: uuid,
+    contentHash: hash,
+    baseRevision: z.number().int().min(0),
+});
+const kind = z.enum([
+    'engineering_rule',
+    'project_profile',
+    'service_contract',
+    'localization_contract',
+    'navigation_contract',
+    'state_contract',
+    'screen_logic',
+    'flow_logic',
+    'module_logic',
+    'data_model',
+    'api_endpoint',
+    'component_mapping',
+    'figma_mapping',
+    'figma_reference',
+    'current_deviation',
+    'quality_gate',
+    'architecture_template',
+]);
+const output = (result) => ({
+    content: [{ type: 'text', text: JSON.stringify(result) }],
+    ...(!result.ok ? { isError: true } : {}),
+});
+const body = (value) => JSON.parse(JSON.stringify(value));
+const onboardingMode = z.enum(['greenfield', 'adopt', 'rework', 'refresh']);
+const profile = z
+    .strictObject({
+    stack: z.enum(['Flutter', 'React', 'Nest', 'Spring']),
+    runtime: z.string().min(1).max(160),
+    architecture: z.string().min(1).max(240),
+    serviceReadiness: z.string().min(1).max(160),
+    apiContract: z.string().min(1).max(160),
+    authentication: z.string().min(1).max(160),
+    storage: z.string().min(1).max(160),
+    environments: z.string().min(1).max(160),
+    backendProjectIds: z
+        .array(uuid)
+        .max(10)
+        .refine((ids) => new Set(ids).size === ids.length),
+    figma: z.string().min(1).max(160).optional(),
+    colorPalette: z.string().min(1).max(240).optional(),
+    typography: z.string().min(1).max(240).optional(),
+    designSystem: z.string().min(1).max(160).optional(),
+    navigation: z.string().min(1).max(160).optional(),
+    platforms: z.string().min(1).max(160).optional(),
+    localization: z.string().min(1).max(160).optional(),
+    migrations: z.string().min(1).max(160).optional(),
+})
+    .superRefine((value, context) => {
+    const required = ['Flutter', 'React'].includes(value.stack)
+        ? [
+            'figma',
+            'colorPalette',
+            'typography',
+            'designSystem',
+            'navigation',
+            'platforms',
+            'localization',
+        ]
+        : ['migrations'];
+    for (const key of required)
+        if (!value[key])
+            context.addIssue({
+                code: 'custom',
+                path: [key],
+                message: 'Collect this choice through the native onboarding form. An explicit absence or deferral must be stated.',
+            });
+});
+const onboardingInput = z.strictObject({
+    repoRoot,
+    requestKey: z.string().regex(/^[A-Za-z0-9_-]{1,80}$/),
+    mode: onboardingMode,
+    profile,
+    projectId: uuid.optional(),
+    reworkBehavior: z.enum(['preserve', 'redesign']).optional(),
+});
+export function registerOnboardingTools(server, service) {
+    server.registerTool('project.inspect', {
+        description: 'Read-only maturity evidence for missing, empty, starter or established projects. Inspect architecture, state, services, network and persistence as well as screens; recommendations never override the user. Follow with a native mode questionnaire.',
+        inputSchema: z.object({ repoRoot }),
+    }, async (input) => output(await service.projectInspect(input)));
+    server.registerTool('project.onboard', {
+        description: 'Choose greenfield, adopt, rework or refresh through durable native forms, then approve a stack-specific profile: palette, fonts/text styles, Figma, navigation, ready services and accessible backend links, or backend API/storage/migrations/environment choices. The agent proposes values from evidence and user answers; never invent defaults. The exact choice persists outside the repository and, with projectId, in the project onboarding record. This does not activate an engineering-memory revision.',
+        inputSchema: onboardingInput,
+    }, async (input, context) => approveOnboarding(server, service, input, context, false));
+    server.registerTool('project.initialize', {
+        description: 'Choose the onboarding mode and profile through native forms before creating a folder or Git. Only an approved greenfield choice initializes Git; preserves existing files, including barely-started projects. Other choices return without changing source. Use the exact same requestKey/profile for retries.',
+        inputSchema: onboardingInput,
+    }, async (input, context) => approveOnboarding(server, service, input, context, true));
+    server.registerTool('project.onboarding_status', {
+        description: 'Read persistent project onboarding choices and rework plans. Old projects have an empty list until onboarding is explicitly chosen.',
+        inputSchema: z
+            .strictObject({
+            projectId: uuid.optional(),
+            onboardingId: uuid.optional(),
+            repoRoot: repoRoot.optional(),
+            requestKey: z
+                .string()
+                .regex(/^[A-Za-z0-9_-]{1,80}$/)
+                .optional(),
+            afterId: uuid.optional(),
+            limit: z.number().int().min(1).max(100).optional(),
+        })
+            .refine((input) => Boolean(input.projectId || (input.repoRoot && input.requestKey)), {
+            message: 'Supply projectId for the project record or repoRoot/requestKey to resume a pre-Git local choice.',
+        }),
+    }, async (input) => input.projectId
+        ? output(await service.onboardingRequest('onboarding_status', body({
+            projectId: input.projectId,
+            onboardingId: input.onboardingId,
+            afterId: input.afterId,
+            limit: input.limit,
+        })))
+        : output(await service.onboardingChoice({
+            repoRoot: input.repoRoot,
+            requestKey: input.requestKey,
+            preparation: true,
+        })));
+    server.registerTool('project.rework_plan', {
+        description: 'After completed deep learning and approved target-architecture revisions, approve an exact phased plan through a native form. Materializes real dependency-ordered WorkItems atomically and idempotently. Each phase names inspected units and a branch; later implementation uses existing task.branch/worktrees and each repository lifecycle. No source changes happen here.',
+        inputSchema: z.strictObject({
+            ...run,
+            repoRoot,
+            onboardingId: uuid,
+            requestKey: z.string().regex(/^[A-Za-z0-9_-]{1,80}$/),
+            targetRevisions: z
+                .array(z.strictObject({ resourceId: uuid, revisionId: uuid, contentHash: hash }))
+                .min(1)
+                .max(100),
+            phases: z
+                .array(z.strictObject({
+                key: z.string().min(1).max(120),
+                title: z.string().min(1).max(160),
+                description: z.string().min(1).max(4000),
+                acceptanceCriteria: z.array(z.string().min(1).max(4000)).min(1).max(50),
+                unitKeys: z.array(z.string().min(1).max(240)).min(1).max(100),
+                dependsOn: z.array(z.string().min(1).max(120)).max(100),
+                branch: z.string().min(1).max(255),
+            }))
+                .min(1)
+                .max(100),
+        }),
+    }, async (input, context) => {
+        const { repoRoot: root, ...plan } = input;
+        const digest = sha256(stableStringify(plan));
+        const answer = await askQuestionnaire(server, service, {
+            repoRoot: root,
+            questionnaireId: 'rework-' + digest,
+            message: 'Approve the phased rework plan already presented in full, including target revisions, units, acceptance criteria and branches? Digest: ' +
+                digest +
+                '. Creates work items only; each implementation needs its normal branch/worktree lifecycle.',
+            options: [
+                { id: 'approve', label: 'Create these exact phases' },
+                { id: 'defer', label: 'Keep the plan for further review' },
+            ],
+        }, context);
+        if (answerChoice(answer) !== 'approve')
+            return answer;
+        return output(await service.onboardingRequest('rework', body(plan)));
+    });
+    server.registerTool('memory.source', {
+        description: 'Read a bounded page of a committed Git manifest, or one file at an exact commit. Never reads dirty worktree content into shared memory. Exclusions carry reasons. Use afterPath for every remaining manifest page. File reads return bounded character chunks; follow nextOffset until null. maxBytes permits regular files up to 16 MiB; larger sources require Git reads at the same pinned commit.',
+        inputSchema: z.object({
+            repoRoot,
+            ref: z.string().optional(),
+            commit: z.string().optional(),
+            previousCommit: z.string().optional(),
+            path: z.string().optional(),
+            afterPath: z.string().optional(),
+            offset: z.number().int().min(0).optional(),
+            maxCharacters: z.number().int().min(1).max(100000).optional(),
+            maxBytes: z.number().int().min(1).max(16777216).optional(),
+            limit: z.number().int().min(1).max(1000).optional(),
+        }),
+    }, async (input) => output(await service.memorySource(input)));
+    server.registerTool('memory.sync_start', {
+        description: 'Start or resume an idempotent committed-source inspection after native mode approval. Uploads all manifest pages, including exclusions. Request key and source are immutable. Refresh references a completed earlier run; rework requires preserve/redesign. Analyze with the current agent; no backend LLM.',
+        inputSchema: z.object({
+            ...project,
+            repoRoot,
+            requestKey: z.string().regex(/^[a-zA-Z0-9_-]{1,120}$/),
+            mode: z.enum(['adopt', 'refresh', 'rework']),
+            ref: z.string().optional(),
+            previousRunId: uuid.optional(),
+            reworkBehavior: z.enum(['preserve', 'redesign']).optional(),
+        }),
+    }, async (input, context) => {
+        const source = await service.memorySource({
+            repoRoot: input.repoRoot,
+            ref: input.ref ?? 'HEAD',
+            limit: 1,
+        });
+        if (!source.ok)
+            return output(source);
+        const commit = source.data.commit;
+        if (typeof commit !== 'string')
+            return output({
+                ok: false,
+                error: {
+                    kind: 'bridge_error',
+                    message: 'The source has no commit identity.',
+                    retryable: false,
+                    recovery: 'memory.sync_status',
+                },
+            });
+        const pinned = { ...input, ref: commit };
+        const digest = sha256(stableStringify(pinned));
+        const question = await askQuestionnaire(server, service, {
+            repoRoot: input.repoRoot,
+            questionnaireId: 'sync-start-' + digest,
+            message: 'Start ' +
+                input.mode +
+                ' for committed source ' +
+                commit +
+                '? Inspect architecture, state, services, network, data, screens and flows; dirty changes stay local. ' +
+                (input.reworkBehavior ? 'Rework target: ' + input.reworkBehavior + '. ' : '') +
+                'Exact request: ' +
+                digest,
+            options: [
+                { id: 'approve', label: 'Start this exact inspection' },
+                { id: 'defer', label: 'Keep inspection unstarted' },
+            ],
+        }, context);
+        if (answerChoice(question) !== 'approve')
+            return question;
+        return output(await service.memorySyncStart({ ...pinned, questionnaireId: 'sync-start-' + digest }));
+    });
+    server.registerTool('memory.sync_status', {
+        description: 'List resumable inspections for a project, or page the units and coverage counters of one run. Tokens are not exposed here; resume an owned claim through memory.sync_next with its saved token.',
+        inputSchema: z.object({
+            ...project,
+            ...page,
+            runId: uuid.optional(),
+            repoRoot: repoRoot.optional(),
+        }),
+    }, async (input) => output(await service.memorySyncStatus(input)));
+    server.registerTool('memory.sync_inventory', {
+        description: 'Upload an immutable manifest page. Prefer sync_start which derives it from real Git. Seal only when all pages match the pinned hash and file count.',
+        inputSchema: z.object({
+            ...run,
+            files: z
+                .array(z.object({
+                path: z.string().min(1).max(1000),
+                blobHash: z.string().regex(/^([a-f0-9]{40}|[a-f0-9]{64})$/),
+                category: z.enum([
+                    'source',
+                    'test',
+                    'config',
+                    'docs',
+                    'assets',
+                    'generated',
+                    'vendor',
+                    'secret',
+                    'submodule',
+                    'binary',
+                    'symlink',
+                ]),
+                excludedReason: z.string().min(1).max(1000).optional(),
+            }))
+                .max(1000),
+            seal: z.boolean().optional(),
+        }),
+    }, async (input) => output(await service.onboardingRequest('inventory', body(input))));
+    server.registerTool('memory.sync_plan', {
+        description: 'Plan module, state, service, network, data, screen and cross-module flow units. Every included file and removed behavior needs coverage. Preserve source facts separately from inference or unknown intent. dependsOn names units affected when dependencies change. Sealing requires a coverage map for architecture, state, services, network, persistence, screens, navigation and flows. Map each area to compatible unit keys and inventory evidence, or document its absence; declarations do not prove semantic correctness.',
+        inputSchema: z.object({
+            ...run,
+            units: z
+                .array(z.object({
+                unitKey: z.string().regex(/^[a-zA-Z0-9_./-]{1,240}$/),
+                moduleKey: z.string().regex(/^[a-zA-Z0-9_./-]{1,240}$/),
+                kind,
+                paths: z.array(z.string().min(1).max(1000)).min(1).max(500),
+                dependsOn: z.array(z.string().max(240)).max(100),
+            }))
+                .max(100),
+            coverage: z
+                .strictObject({
+                architecture: z.strictObject({
+                    unitKeys: z.array(z.string().min(1).max(240)).max(10000),
+                    evidencePaths: z.array(z.string().min(1).max(1000)).max(10000),
+                    notApplicableReason: z.string().min(1).max(2000).optional(),
+                }),
+                state: z.strictObject({
+                    unitKeys: z.array(z.string().min(1).max(240)).max(10000),
+                    evidencePaths: z.array(z.string().min(1).max(1000)).max(10000),
+                    notApplicableReason: z.string().min(1).max(2000).optional(),
+                }),
+                services: z.strictObject({
+                    unitKeys: z.array(z.string().min(1).max(240)).max(10000),
+                    evidencePaths: z.array(z.string().min(1).max(1000)).max(10000),
+                    notApplicableReason: z.string().min(1).max(2000).optional(),
+                }),
+                network: z.strictObject({
+                    unitKeys: z.array(z.string().min(1).max(240)).max(10000),
+                    evidencePaths: z.array(z.string().min(1).max(1000)).max(10000),
+                    notApplicableReason: z.string().min(1).max(2000).optional(),
+                }),
+                persistence: z.strictObject({
+                    unitKeys: z.array(z.string().min(1).max(240)).max(10000),
+                    evidencePaths: z.array(z.string().min(1).max(1000)).max(10000),
+                    notApplicableReason: z.string().min(1).max(2000).optional(),
+                }),
+                screens: z.strictObject({
+                    unitKeys: z.array(z.string().min(1).max(240)).max(10000),
+                    evidencePaths: z.array(z.string().min(1).max(1000)).max(10000),
+                    notApplicableReason: z.string().min(1).max(2000).optional(),
+                }),
+                navigation: z.strictObject({
+                    unitKeys: z.array(z.string().min(1).max(240)).max(10000),
+                    evidencePaths: z.array(z.string().min(1).max(1000)).max(10000),
+                    notApplicableReason: z.string().min(1).max(2000).optional(),
+                }),
+                flows: z.strictObject({
+                    unitKeys: z.array(z.string().min(1).max(240)).max(10000),
+                    evidencePaths: z.array(z.string().min(1).max(1000)).max(10000),
+                    notApplicableReason: z.string().min(1).max(2000).optional(),
+                }),
+            })
+                .optional(),
+            seal: z.boolean().optional(),
+        }),
+    }, async (input) => output(await service.onboardingRequest('plan', body(input))));
+    server.registerTool('memory.sync_next', {
+        description: 'Claim the next unit for fifteen minutes. Fresh parallel calls use distinct requestKeys; retry the same requestKey after response loss. Save the returned claimToken and use it to resume or renew the same unit. Analysis happens outside the transaction.',
+        inputSchema: z
+            .object({
+            ...run,
+            claimToken: uuid.optional(),
+            requestKey: z
+                .string()
+                .regex(/^[A-Za-z0-9_-]{1,120}$/)
+                .optional(),
+        })
+            .refine((input) => Boolean(input.claimToken || input.requestKey), {
+            message: 'Use a unique requestKey for a fresh claim or the saved claimToken to resume.',
+        }),
+    }, async (input) => output(await service.onboardingRequest('next', body(input))));
+    server.registerTool('memory.sync_submit', {
+        description: 'Submit immutable source/execution evidence, behavior facets, gaps, and exact proposal/unchanged revision references. Each source/execution witness declares evidence.facets; behavior facet references must point to witnesses for that facet. Facets: entry, exit, authority, effects, errors, cancellation, retry, persistence, dependencies. Proposals must carry provenance {sourceCommit,runId,unitKey}. No historical tasks or motivations may be invented.',
+        inputSchema: z.object({ ...run, unitId: uuid, claimToken: uuid, submission: object }),
+    }, async (input) => output(await service.onboardingRequest('submit', body(input))));
+    server.registerTool('memory.sync_reopen', {
+        description: 'Reopen an unfinished unit after rejected proposals or incomplete evidence, using its current lockVersion as expectedVersion. Completed runs are immutable: refresh instead.',
+        inputSchema: z.object({ ...run, unitId: uuid, expectedVersion: z.number().int().min(1) }),
+    }, async (input) => output(await service.onboardingRequest('reopen', body(input))));
+    server.registerTool('memory.sync_delta', {
+        description: 'Page previous units whose source, memory revisions or transitive dependencies changed. Uses content hashes even after squash/history loss. Re-plan deletions for reviewed archival; compare unchanged units against exact current revisions without making no-op proposals.',
+        inputSchema: z.strictObject({ ...run, ...page, repoRoot: repoRoot.optional() }),
+    }, async (input) => output(await service.memorySyncDelta(input)));
+    server.registerTool('memory.sync_verify', {
+        description: 'Verify sealed inventory, semantic file coverage, complete behavior evidence, absence of unresolved gaps and approved immutable memory references. This inspection gate does not replace or weaken task.verify for code changes.',
+        inputSchema: z.object(run),
+    }, async (input) => output(await service.onboardingRequest('verify', body(input))));
+    server.registerTool('memory.catalog', {
+        description: 'Page accessible memory resource headers by id. Read all pages using the last id when a page is full. includeArchived exposes retired identities for refresh and rename preservation.',
+        inputSchema: z.object({
+            ...project,
+            ...page,
+            includeArchived: z.boolean().optional(),
+            includeLinked: z.boolean().optional(),
+            kinds: z.array(kind).max(100).optional(),
+        }),
+    }, async (input) => output(await service.onboardingRequest('catalog', body(input))));
+    server.registerTool('memory.read_revisions', {
+        description: 'Read selected immutable revisions in an authorized context session and record receipts. Bounds keep large project learning independent of normal task context limits.',
+        inputSchema: z.object({
+            ...project,
+            sessionId: uuid,
+            revisionIds: z.array(uuid).min(1).max(100),
+        }),
+    }, async (input) => output(await service.onboardingRequest('read_revisions', body(input))));
+    server.registerTool('memory.review_batch', {
+        description: 'After presenting full module proposal contents, evidence, uncertainties and archive actions through memory.list_proposals, collect native approval for these exact proposal ids, hashes and base revisions. Pending/dismissed forms never write. All reviews commit atomically; stale revisions fail.',
+        inputSchema: z.strictObject({
+            ...project,
+            repoRoot,
+            entries: z.array(reference).min(1).max(20),
+            reviewAttempt: z.number().int().min(0).max(10000).default(0),
+        }),
+    }, async (input, context) => {
+        const entries = [...input.entries].sort((a, b) => a.proposalId.localeCompare(b.proposalId));
+        const digest = sha256(stableStringify({ projectId: input.projectId, entries }));
+        const result = await askQuestionnaire(server, service, {
+            repoRoot: input.repoRoot,
+            questionnaireId: 'memory-batch-' + digest + '-' + input.reviewAttempt,
+            message: 'Review the exact module batch already presented in full. Batch digest: ' +
+                digest +
+                '\nProposals:\n' +
+                entries.map((e) => e.proposalId).join('\n') +
+                '\nApprove publishes the listed contents; reject leaves active memory unchanged.',
+            options: [
+                { id: 'approved', label: 'Approve this exact batch' },
+                { id: 'rejected', label: 'Reject this exact batch' },
+                { id: 'defer', label: 'Leave these proposals pending' },
+            ],
+        }, context);
+        const decision = answerChoice(result);
+        if (decision === 'defer')
+            return output({
+                ok: true,
+                data: {
+                    status: 'deferred',
+                    digest,
+                    reviewAttempt: input.reviewAttempt,
+                    nextReviewAttempt: input.reviewAttempt + 1,
+                    nextAction: 'When the user is ready to review again, call memory.review_batch with the same exact entries and nextReviewAttempt as reviewAttempt. Retrying this attempt preserves the deferral.',
+                },
+            });
+        if (decision !== 'approved' && decision !== 'rejected')
+            return result;
+        return output(await service.onboardingRequest('review_batch', body({
+            projectId: input.projectId,
+            entries,
+            decision,
+            note: 'Native module-batch review ' + digest,
+        })));
+    });
+}
+function answerChoice(result) {
+    return answerData(result)?.choice;
+}
+function answerData(result) {
+    const response = result;
+    const text = response.content?.find((item) => item.type === 'text')?.text;
+    if (!text)
+        return undefined;
+    const value = JSON.parse(text);
+    return value.ok && value.data?.status === 'answered' && value.data.answerAvailable
+        ? value.data.answer
+        : undefined;
+}
+async function approveOnboarding(server, service, input, context, initialize) {
+    const preparation = !input.projectId;
+    const scope = { repoRoot: input.repoRoot, preparation };
+    const mode = await askQuestionnaire(server, service, {
+        ...scope,
+        questionnaireId: 'onboard-mode-' + sha256(input.requestKey),
+        message: 'Based on project.inspect, choose how this project should enter Engineering Memory. Choosing an existing architecture never rewrites it.',
+        options: [
+            { id: 'greenfield', label: 'Set up a new or barely-started project' },
+            { id: 'adopt', label: 'Learn and preserve the existing architecture' },
+            { id: 'rework', label: 'Learn first, then plan a phased rework' },
+            ...(input.projectId
+                ? [{ id: 'refresh', label: 'Refresh memory against the current project' }]
+                : []),
+        ],
+    }, context);
+    const selected = answerChoice(mode);
+    if (!selected)
+        return mode;
+    if (selected !== input.mode)
+        return output({
+            ok: true,
+            data: {
+                mode: selected,
+                nextAction: 'Resume project.onboard with this exact mode; the native profile questionnaire will continue with the same requestKey. No source was changed.',
+            },
+        });
+    if (selected === 'rework') {
+        const behavior = await askQuestionnaire(server, service, {
+            ...scope,
+            questionnaireId: 'rework-behavior-' + sha256(input.requestKey),
+            message: 'Should rework preserve current observable behavior or redesign the product? Redesign requires approved target screens, flows and contracts before implementation.',
+            options: [
+                { id: 'preserve', label: 'Preserve current behavior' },
+                { id: 'redesign', label: 'Redesign the product explicitly' },
+            ],
+        }, context);
+        const chosen = answerChoice(behavior);
+        if (!chosen)
+            return behavior;
+        if (chosen !== input.reworkBehavior)
+            return output({
+                ok: true,
+                data: {
+                    mode: selected,
+                    reworkBehavior: chosen,
+                    nextAction: 'Resume project.onboard with this exact behavior choice; native profile questions will continue.',
+                },
+            });
+    }
+    const effectiveProfile = body(input.profile);
+    const processedFields = new Set();
+    let fields = profileFields(effectiveProfile);
+    for (let index = 0; index < fields.length; index += 1) {
+        const [field, label] = fields[index];
+        if (processedFields.has(field))
+            continue;
+        const currentValue = effectiveProfile[field] ?? null;
+        const digest = sha256(stableStringify({
+            requestKey: input.requestKey,
+            mode: input.mode,
+            reworkBehavior: input.reworkBehavior ?? null,
+            field,
+            currentValue,
+        }));
+        const response = await askQuestionnaire(server, service, {
+            ...scope,
+            questionnaireId: 'onboard-field-' + field + '-' + digest,
+            message: 'Review this onboarding choice before it is persisted.\n' +
+                'Field: ' +
+                label +
+                '\nCurrent value:\n' +
+                JSON.stringify(currentValue, null, 2) +
+                '\nKeep it, edit it in the bounded field below, or defer this field explicitly. A deferred field remains pending and is never silently saved as the current value.',
+            options: profileFieldOptions(field, currentValue),
+            ...(field === 'stack'
+                ? {}
+                : {
+                    textField: {
+                        title: field === 'backendProjectIds' ? 'Project ID JSON array' : 'Edited value',
+                        maxLength: field === 'backendProjectIds'
+                            ? 2000
+                            : ['architecture', 'colorPalette', 'typography'].includes(field)
+                                ? 240
+                                : 160,
+                        requiredForChoice: 'edit_value',
+                        ...(field === 'backendProjectIds' ? { valueType: 'uuid_list' } : {}),
+                    },
+                }),
+        }, context);
+        const answer = answerData(response);
+        const choice = answer?.choice;
+        if (!choice)
+            return response;
+        if (choice === 'defer_current')
+            return deferredProfile(input.requestKey, field);
+        if (field === 'stack' && stackValues.includes(choice)) {
+            effectiveProfile.stack = choice;
+            processedFields.add(field);
+            fields = profileFields(effectiveProfile);
+            continue;
+        }
+        if (choice === 'edit_value') {
+            if (!answer.text)
+                return response;
+            effectiveProfile[field] = parseEditedProfileValue(field, answer.text);
+        }
+        processedFields.add(field);
+        fields = profileFields(effectiveProfile);
+    }
+    const choice = {
+        requestKey: input.requestKey,
+        mode: input.mode,
+        profile: body(onboardingInput.parse({ ...input, profile: effectiveProfile }).profile),
+        ...(input.reworkBehavior ? { reworkBehavior: input.reworkBehavior } : {}),
+    };
+    const digest = sha256(stableStringify(choice));
+    const questionnaireId = 'onboard-profile-' + digest + (initialize ? '-initialize' : '-save');
+    const approval = await askQuestionnaire(server, service, {
+        ...scope,
+        questionnaireId,
+        message: 'Save the selected mode and the profile choices just reviewed? Mode: ' +
+            input.mode +
+            '. Exact choice digest: ' +
+            digest +
+            '. ' +
+            (initialize ? 'Greenfield will prepare Git without replacing existing files. ' : '') +
+            'Engineering-memory revisions and project links require their own review/authority.',
+        options: [
+            { id: 'approve', label: 'Save these exact onboarding choices' },
+            { id: 'defer', label: 'Keep the choices pending' },
+        ],
+    }, context);
+    if (answerChoice(approval) === 'defer')
+        return deferredProfile(input.requestKey, 'final-profile');
+    if (answerChoice(approval) !== 'approve')
+        return approval;
+    const saved = initialize
+        ? await service.projectInitialize({
+            ...scope,
+            requestKey: input.requestKey,
+            choice,
+            questionnaireId,
+        })
+        : await service.onboardingChoice({
+            ...scope,
+            requestKey: input.requestKey,
+            choice,
+            questionnaireId,
+        });
+    if (!saved.ok || !input.projectId)
+        return output(saved);
+    return output(await service.onboardingRequest('onboarding_choose', body({ projectId: input.projectId, ...choice })));
+}
+function deferredProfile(requestKey, field) {
+    return output({
+        ok: true,
+        data: {
+            status: 'deferred',
+            field,
+            nextRequestKey: 'reconsider-' + sha256(requestKey).slice(0, 48),
+            nextAction: 'No onboarding choice was saved. Retrying this request preserves the deferral. When the user explicitly resumes this decision, call project.onboard or project.initialize with nextRequestKey to collect fresh native choices; do not infer approval.',
+        },
+    });
+}
+function parseEditedProfileValue(field, value) {
+    if (field !== 'backendProjectIds')
+        return value.trim();
+    const parsed = JSON.parse(value);
+    return z.array(uuid).max(10).parse(parsed);
+}
+const stackValues = ['Flutter', 'React', 'Nest', 'Spring'];
+function profileFieldOptions(field, currentValue) {
+    if (field === 'stack') {
+        return [
+            { id: 'keep_current', label: 'Keep this exact value' },
+            ...stackValues
+                .filter((value) => value !== currentValue)
+                .map((value) => ({ id: value, label: `Change to ${value}` })),
+            { id: 'defer_current', label: 'Defer this value explicitly' },
+        ];
+    }
+    return [
+        ...(currentValue === null ? [] : [{ id: 'keep_current', label: 'Keep this exact value' }]),
+        { id: 'edit_value', label: 'Edit this value in the field below' },
+        { id: 'defer_current', label: 'Defer this value explicitly' },
+    ];
+}
+function profileFields(profileValue) {
+    const fields = [
+        ['stack', 'Application stack'],
+        ['runtime', 'Runtime and toolchain contract'],
+        ['architecture', 'Application architecture'],
+        ['environments', 'Environments and configuration'],
+        ['serviceReadiness', 'Service readiness'],
+        ['apiContract', 'API contract'],
+        ['authentication', 'Authentication'],
+        ['storage', 'Storage and persistence'],
+        ['backendProjectIds', 'Existing backend project links'],
+    ];
+    if (['Nest', 'Spring'].includes(profileValue.stack))
+        fields.push(['migrations', 'Migration strategy']);
+    if (['Flutter', 'React'].includes(profileValue.stack)) {
+        fields.push(['figma', 'Figma source'], ['colorPalette', 'Color palette'], ['typography', 'Font families and text styles'], ['designSystem', 'Design system'], ['navigation', 'Navigation'], ['platforms', 'Platforms'], ['localization', 'Localization languages']);
+    }
+    return fields;
+}
+//# sourceMappingURL=onboarding-tools.js.map