engineering-memory 1.10.3 → 1.10.5

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

@@ -1,8 +1,8 @@
 import { acceptedContent, CLIENT_CAPABILITIES_META_KEY, inputRequired, inputResponse, } from '@modelcontextprotocol/server';
 import { questionnaireAnswerSchema, } from '../runtime/questionnaire-store.js';
-export async function askQuestionnaire(server, service, input, context) {
+export async function askQuestionnaire(server, service, input, context, previousDefinitions = []) {
     try {
-        return await present(server, service, await service.questionnaireAsk(input), input.repoRoot, context);
+        return await present(server, service, await service.questionnaireAsk(input, previousDefinitions), input.repoRoot, context, input.preparation);
     }
     catch (error) {
         return failure(error);
@@ -10,13 +10,20 @@ export async function askQuestionnaire(server, service, input, context) {
 }
 export async function resumeQuestionnaire(server, service, input, context) {
     try {
-        return await present(server, service, await service.questionnaireResume(input), input.repoRoot, context);
+        return await present(server, service, await service.questionnaireResume(input), input.repoRoot, context, input.preparation);
     }
     catch (error) {
         return failure(error);
     }
 }
-async function present(server, service, record, repoRoot, context) {
+async function present(server, service, record, repoRoot, context, preparation) {
+    if (record.status === 'withdrawn')
+        return result({
+            questionnaireId: record.questionnaireId,
+            status: 'withdrawn',
+            answerAvailable: false,
+            nextAction: 'This decision was explicitly withdrawn. Do not continue dependent work. Use a new questionnaireId or onboarding requestKey only if the user resumes that work.',
+        });
     if (record.status === 'answered')
         return answered(record, record.answer, true);
     if (context.mcpReq.signal.aborted)
@@ -29,6 +36,7 @@ async function present(server, service, record, repoRoot, context) {
             return pending(record, 'invalid_response');
         const resolved = await service.questionnaireAccept({
             repoRoot,
+            preparation,
             questionnaireId: record.questionnaireId,
             requestKey: record.requestKey,
             scope: record.scope,
@@ -45,36 +53,47 @@ async function present(server, service, record, repoRoot, context) {
     const elicitation = capabilities?.elicitation;
     if (!elicitation || (!elicitation.form && elicitation.url !== undefined))
         return pending(record, 'native_form_unavailable');
+    const copy = questionnaireCopy[record.language ?? 'en'];
     return inputRequired({
         inputRequests: {
             [record.requestKey]: inputRequired.elicit({
                 mode: 'form',
-                message: `${record.message}\n\nChoose an answer to resolve this decision. Closing or cancelling the form leaves it pending.${record.allowFreeText ? ' For another answer choose Other and fill in text. Free text is not stored and cannot be replayed.' : ''}`,
+                message: `${record.message}\n\n${copy.pending}${record.allowFreeText ? copy.freeText : ''}${record.textField ? copy.storedText : ''}`,
                 requestedSchema: {
                     type: 'object',
                     properties: {
                         choice: {
                             type: 'string',
-                            title: 'Answer',
+                            title: copy.answer,
                             enum: [
                                 ...record.options.map((option) => option.id),
                                 ...(record.allowFreeText ? ['__other__'] : []),
                             ],
                             enumNames: [
                                 ...record.options.map((option) => option.label),
-                                ...(record.allowFreeText ? ['Other'] : []),
+                                ...(record.allowFreeText ? [copy.other] : []),
                             ],
                         },
                         ...(record.allowFreeText
                             ? {
                                 text: {
                                     type: 'string',
-                                    title: 'Other answer',
+                                    title: copy.otherAnswer,
                                     minLength: 1,
                                     maxLength: 2000,
                                 },
                             }
                             : {}),
+                        ...(record.textField
+                            ? {
+                                text: {
+                                    type: 'string',
+                                    title: record.textField.title,
+                                    minLength: 1,
+                                    maxLength: record.textField.maxLength,
+                                },
+                            }
+                            : {}),
                     },
                     required: ['choice'],
                 },
@@ -82,6 +101,24 @@ async function present(server, service, record, repoRoot, context) {
         },
     });
 }
+const questionnaireCopy = {
+    en: {
+        pending: 'Choose an answer to resolve this decision. Closing or cancelling the form leaves it pending.',
+        freeText: ' For another answer choose Other and fill in text. Free text is not stored and cannot be replayed.',
+        storedText: ' The bounded text field is stored as part of this exact decision and is replayed after restart.',
+        answer: 'Answer',
+        other: 'Other',
+        otherAnswer: 'Other answer',
+    },
+    tr: {
+        pending: 'Kararını kaydetmek için bir seçenek seç. Formu kapatmak veya iptal etmek onay sayılmaz; soru beklemede kalır.',
+        freeText: ' Farklı bir yanıt için Diğer seçeneğini seçip metin alanını doldur. Serbest yanıt saklanmaz ve daha sonra geri getirilemez.',
+        storedText: ' Bu metin alanındaki yanıt kararınla birlikte saklanır; yeniden başlattığında korunur.',
+        answer: 'Yanıt',
+        other: 'Diğer',
+        otherAnswer: 'Diğer yanıt',
+    },
+};
 function pending(record, reason) {
     return result({
         questionnaireId: record.questionnaireId,

package/runtime/dist/src/mcp/server.js

@@ -1,4 +1,5 @@
 import { McpServer } from '@modelcontextprotocol/server';
+import { registerOnboardingTools } from './onboarding-tools.js';
 import { registerEngineeringMemoryTools, registerQuestionnaireTools } from './tool-definitions.js';
 export function createEngineeringMemoryServer(service) {
     const server = new McpServer({
@@ -7,6 +8,7 @@ export function createEngineeringMemoryServer(service) {
     });
     registerEngineeringMemoryTools(server, service);
     registerQuestionnaireTools(server, service);
+    registerOnboardingTools(server, service);
     return server;
 }
 //# sourceMappingURL=server.js.map

package/runtime/dist/src/mcp/tool-definitions.js

@@ -49,6 +49,7 @@ export const engineeringMemoryToolNames = [
     'audit.list',
     'questionnaire.ask',
     'questionnaire.resume',
+    'questionnaire.withdraw',
     'session.entry',
     'session.set_decision',
     'session.decline_update',
@@ -57,6 +58,24 @@ export const engineeringMemoryToolNames = [
     'session.resume',
     'context.prepare_change',
     'context.refresh',
+    'project.inspect',
+    'project.onboard',
+    'project.onboarding_status',
+    'project.rework_plan',
+    'project.initialize',
+    'memory.source',
+    'memory.sync_start',
+    'memory.sync_status',
+    'memory.sync_inventory',
+    'memory.sync_plan',
+    'memory.sync_next',
+    'memory.sync_submit',
+    'memory.sync_reopen',
+    'memory.sync_delta',
+    'memory.sync_verify',
+    'memory.catalog',
+    'memory.read_revisions',
+    'memory.review_batch',
     'memory.query',
     'memory.history',
     'memory.propose_revision',
@@ -121,15 +140,49 @@ const reconciliationEntry = z.object({
     reason: z.string().optional(),
 });
 export function registerQuestionnaireTools(server, service) {
+    server.registerTool('questionnaire.withdraw', {
+        description: 'Withdraw a pending decision only when the user explicitly cancels that decision or its owning workflow. This is not approval. An answered decision is immutable. Interruption, timeout and dismissal alone never authorize withdrawal.',
+        inputSchema: z.strictObject({
+            repoRoot: optionalRepoRoot,
+            questionnaireId: z.string().regex(/^[A-Za-z0-9_-]{1,100}$/),
+            preparation: z.boolean().optional(),
+        }),
+    }, async (input) => {
+        try {
+            const record = await service.questionnaireWithdraw(input);
+            return toolResult({
+                ok: true,
+                data: {
+                    questionnaireId: record.questionnaireId,
+                    status: record.status,
+                    answerAvailable: record.answerAvailable ?? false,
+                },
+            });
+        }
+        catch {
+            return toolResult({
+                ok: false,
+                error: {
+                    kind: 'bridge_error',
+                    message: 'Cannot withdraw this questionnaire. Check the account and repository with session.entry and the exact questionnaireId with questionnaire.resume.',
+                    retryable: false,
+                },
+            });
+        }
+    });
     server.registerTool('questionnaire.ask', {
-        description: 'Persist a required decision before displaying a native questionnaire. Use a questionnaireId unique to this decision occurrence or task, and reuse it only for identical retries. A later decision or changed wording/options requires a new id. Only a schema-validated native acceptance answers it. Dismissal, timeout and missing replies remain pending without expiry. Never supply answers in tool arguments. Do not put personal information or secrets in the question or options. Free text is returned once and never stored; use explicit options for replayable decisions.',
-        inputSchema: questionnaireDefinitionSchema.extend({ repoRoot: optionalRepoRoot }),
+        description: 'Persist a required decision before displaying a native questionnaire. Write the message and labels in the conversation language and set language (tr or en) for the native form help. Use a questionnaireId unique to this decision occurrence or task, and reuse it only for identical retries. A later decision or changed wording/options requires a new id. Only a schema-validated native acceptance answers it. Dismissal, timeout and missing replies remain pending without expiry. Never supply answers in tool arguments. Do not put personal information or secrets in the question or options. Free text is returned once and never stored; use explicit options for replayable decisions.',
+        inputSchema: questionnaireDefinitionSchema.extend({
+            repoRoot: optionalRepoRoot,
+            preparation: z.boolean().optional(),
+        }),
     }, async (input, context) => await askQuestionnaire(server, service, input, context));
     server.registerTool('questionnaire.resume', {
         description: 'Display the original durable questionnaire after interruption or return its saved accepted choice. No timeout or dismissal resolves a pending question. A saved free-text receipt cannot replay the text and must never be treated as a recovered answer.',
         inputSchema: z.strictObject({
             repoRoot: optionalRepoRoot,
             questionnaireId: z.string().regex(/^[A-Za-z0-9_-]{1,100}$/),
+            preparation: z.boolean().optional(),
         }),
     }, async (input, context) => await resumeQuestionnaire(server, service, input, context));
 }
@@ -286,6 +339,7 @@ export function registerEngineeringMemoryTools(server, service) {
             tags: stringList.optional(),
             metadata: jsonObject.optional(),
             provenance: jsonObject.optional(),
+            status: z.enum(['active', 'archived']).optional(),
         }),
     }, async (input) => toolResult(await service.memoryProposeRevision(input)));
     server.registerTool('memory.list_proposals', {

package/runtime/dist/src/project/project-intake.js

@@ -0,0 +1,406 @@
+import { lstat, readFile, readdir } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { canonicalPath, ensureManagedDirectory } from '../utilities/files.js';
+import { NativeCommandRunner } from '../utilities/process.js';
+export class ProjectIntake {
+    runner;
+    constructor(runner = new NativeCommandRunner()) {
+        this.runner = runner;
+    }
+    async inspect(repoPath) {
+        const requested = resolve(repoPath);
+        let root;
+        try {
+            const requestedInfo = await lstat(requested);
+            if (requestedInfo.isSymbolicLink())
+                throw new Error('Project path must not be a symbolic link');
+            root = await canonicalPath(requested);
+            const info = await lstat(root);
+            if (!info.isDirectory() || info.isSymbolicLink())
+                throw new Error('Project path must be a real directory');
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                'code' in error &&
+                error.code === 'ENOENT') {
+                return emptyReport(requested, 'missing', ['directory does not exist']);
+            }
+            throw error;
+        }
+        const entries = await readdir(root, { withFileTypes: true });
+        if (entries.length === 0)
+            return emptyReport(root, 'empty', ['directory exists and is empty']);
+        const inventory = await collectInventory(root);
+        const evidence = [];
+        const stacks = [];
+        for (const detected of await detectStacks(root, inventory.manifestCandidates)) {
+            if (stacks.includes(detected.stack))
+                continue;
+            stacks.push(detected.stack);
+            evidence.push(detected.evidence);
+        }
+        const hasGit = await this.runner.run('git', ['rev-parse', '--is-inside-work-tree'], {
+            cwd: root,
+        });
+        const applicationAreas = [
+            'state',
+            'services',
+            'network',
+            'persistence',
+            'architecture',
+            'screens',
+            'components',
+            'navigation',
+        ].filter((area) => inventory.areaCounts[area] > 0);
+        const hasApplicationAreas = applicationAreas.length > 0;
+        if (hasApplicationAreas)
+            evidence.push(`application structural sources found in ${applicationAreas.join(', ')}`);
+        const recommendation = hasApplicationAreas
+            ? 'established'
+            : meaningfulEntries(entries).length === 0
+                ? 'empty'
+                : 'scaffold';
+        const reasons = stacks.length > 0
+            ? hasApplicationAreas
+                ? [`detected ${stacks.join(', ')} with application structural evidence`]
+                : [`detected ${stacks.join(', ')} without application structural evidence`]
+            : hasApplicationAreas
+                ? [`application structural sources found in ${applicationAreas.join(', ')}`]
+                : meaningfulEntries(entries).length === 0
+                    ? ['directory contains only Git metadata']
+                    : hasGit.exitCode === 0
+                        ? [
+                            'Git repository has no recognized stack manifest or application architectural signals',
+                        ]
+                        : [
+                            'directory has content but no recognized stack manifest or application architectural signals',
+                        ];
+        return { repoPath: root, recommendation, reasons, stacks, evidence, inventory };
+    }
+    async initialize(repoPath) {
+        const requested = resolve(repoPath);
+        await assertNoRepositoryAncestor(requested, this.runner);
+        let exists = true;
+        try {
+            const requestedInfo = await lstat(requested);
+            if (requestedInfo.isSymbolicLink())
+                throw new Error('Project path must not be a symbolic link');
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                'code' in error &&
+                error.code === 'ENOENT')
+                exists = false;
+            else
+                throw error;
+        }
+        if (!exists) {
+            await ensureManagedDirectory(dirname(requested), requested);
+        }
+        const root = await canonicalPath(requested);
+        const info = await lstat(root);
+        if (!info.isDirectory() || info.isSymbolicLink())
+            throw new Error('Project path must be a real directory');
+        const parentGit = await this.runner.run('git', ['rev-parse', '--show-toplevel'], { cwd: root });
+        if (parentGit.exitCode === 0 && resolve(parentGit.stdout.trim()) !== root)
+            throw new Error('Refusing to initialize inside an existing parent repository');
+        const gitPath = join(root, '.git');
+        const existingGit = await lstat(gitPath).then((entry) => {
+            if (entry.isSymbolicLink())
+                throw new Error('Refusing to use a symbolic-link .git path');
+            return true;
+        }, (error) => (error.code === 'ENOENT' ? false : Promise.reject(error)));
+        if (existingGit)
+            return { repoPath: root, initialized: false };
+        const result = await this.runner.run('git', ['init', '--quiet', '--'], { cwd: root });
+        if (result.exitCode !== 0)
+            throw new Error(`Git initialization failed: ${result.stderr.trim()}`);
+        return { repoPath: root, initialized: true };
+    }
+}
+function emptyReport(repoPath, recommendation, reasons) {
+    return {
+        repoPath,
+        recommendation,
+        reasons,
+        stacks: [],
+        evidence: [],
+        inventory: {
+            all: [],
+            state: [],
+            services: [],
+            network: [],
+            persistence: [],
+            architecture: [],
+            screens: [],
+            components: [],
+            navigation: [],
+            symlinks: [],
+            totalFiles: 0,
+            omittedFiles: 0,
+            prunedDirectories: [],
+            prunedDirectoryCount: 0,
+            omittedPrunedDirectories: 0,
+            sampleLimit: INVENTORY_SAMPLE_LIMIT,
+            areaCounts: emptyAreaCounts(),
+            manifestCandidates: [],
+            manifestCandidatesOmitted: 0,
+        },
+    };
+}
+async function collectInventory(root) {
+    const all = [];
+    const state = [];
+    const services = [];
+    const network = [];
+    const persistence = [];
+    const architecture = [];
+    const screens = [];
+    const components = [];
+    const navigation = [];
+    const symlinks = [];
+    const prunedDirectories = [];
+    let prunedDirectoryCount = 0;
+    const areaCounts = emptyAreaCounts();
+    const manifestCandidates = [];
+    let manifestCandidatesOmitted = 0;
+    let totalFiles = 0;
+    const walk = async (directory) => {
+        for (const entry of await readdir(directory, { withFileTypes: true })) {
+            if (entry.name === '.git')
+                continue;
+            const path = join(directory, entry.name);
+            const relativePath = path.slice(root.length + 1).replace(/\\/g, '/');
+            if (entry.isSymbolicLink()) {
+                if (symlinks.length < INVENTORY_SAMPLE_LIMIT) {
+                    all.push(relativePath);
+                    symlinks.push(relativePath);
+                }
+                continue;
+            }
+            if (entry.isDirectory()) {
+                if (await shouldPruneDirectory(root, relativePath)) {
+                    prunedDirectoryCount += 1;
+                    if (prunedDirectories.length < INVENTORY_SAMPLE_LIMIT)
+                        prunedDirectories.push(relativePath);
+                    continue;
+                }
+                await walk(path);
+                continue;
+            }
+            totalFiles += 1;
+            const sampled = totalFiles <= INVENTORY_SAMPLE_LIMIT;
+            if (sampled)
+                all.push(relativePath);
+            const lower = relativePath.toLowerCase();
+            if (['package.json', 'pubspec.yaml', 'pom.xml', 'build.gradle', 'build.gradle.kts'].includes(entry.name.toLowerCase())) {
+                if (manifestCandidates.length < MANIFEST_CANDIDATE_LIMIT)
+                    manifestCandidates.push(relativePath);
+                else
+                    manifestCandidatesOmitted += 1;
+            }
+            const addArea = (area, target) => {
+                areaCounts[area] += 1;
+                if (target.length < INVENTORY_SAMPLE_LIMIT)
+                    target.push(relativePath);
+            };
+            if (/(^|\/)(architecture|adr|adrs|design|docs?)(\/|\.|$)|(^|\/)(architecture|adr)[^/]*\.(md|ya?ml|json)$/.test(lower))
+                addArea('architecture', architecture);
+            if (!entry.isFile() ||
+                !/\.(?:[cm]?[jt]sx?|dart|java|kt|kts|swift|cs|go|rs|py|rb|vue|svelte|openapi|graphql)$/.test(lower) ||
+                /(^|\/)(node_modules|vendor|pods|\.dart_tool|\.next|\.nuxt)(\/|$)|\.(g|freezed)\.dart$|(^|\/)(__tests__|tests?|spec)(\/|$)|\.(test|spec)\.[^/]+$|_test\.[^/]+$/.test(lower) ||
+                isCredentialDataPath(lower))
+                continue;
+            if (/(^|\/)(state|store|stores|reducers?|providers?|bloc|cubits?)(\/|\.|$)|(?:state|store|reducer|provider|bloc|cubit)\.[^/]+$/.test(lower))
+                addArea('state', state);
+            if (/(^|\/)(service|services|use-cases?|usecases|domain)(\/|\.|$)|service\.[^/]+$/.test(lower))
+                addArea('services', services);
+            if (/(^|\/)(api|apis|network|http|graphql|routes?|controllers?|clients?)(\/|\.|$)|(?:controller|client)\.[^/]+$|\.(openapi|graphql)$/.test(lower))
+                addArea('network', network);
+            if (/(^|\/)(persistence|repositories?|storage|database|db|migrations?|entities|models?)(\/|\.|$)|(?:repository|entity|model)\.[^/]+$/.test(lower))
+                addArea('persistence', persistence);
+            if (/(^|\/)(screens?|pages?|views?)(\/|\.|$)|(^|\/)[^/]*(?:screen|page|view)\.[^/]+$/.test(lower))
+                addArea('screens', screens);
+            if (/(^|\/)(components?|widgets?)(\/|\.|$)|(^|\/)[^/]*component\.[^/]+$/.test(lower))
+                addArea('components', components);
+            if (/(^|\/)(navigation|routing|routes?|router)(\/|\.|$)|(^|\/)[^/]*(?:navigation|router|routes?)\.[^/]+$/.test(lower))
+                addArea('navigation', navigation);
+        }
+    };
+    await walk(root);
+    const sort = (values) => values.sort((left, right) => (left < right ? -1 : left > right ? 1 : 0));
+    return {
+        all: sort(all),
+        state: sort(state),
+        services: sort(services),
+        network: sort(network),
+        persistence: sort(persistence),
+        architecture: sort(architecture),
+        screens: sort(screens),
+        components: sort(components),
+        navigation: sort(navigation),
+        symlinks: sort(symlinks),
+        totalFiles,
+        omittedFiles: Math.max(0, totalFiles - INVENTORY_SAMPLE_LIMIT),
+        prunedDirectories: sort(prunedDirectories),
+        prunedDirectoryCount,
+        omittedPrunedDirectories: Math.max(0, prunedDirectoryCount - INVENTORY_SAMPLE_LIMIT),
+        sampleLimit: INVENTORY_SAMPLE_LIMIT,
+        areaCounts,
+        manifestCandidates: manifestCandidates.sort(),
+        manifestCandidatesOmitted,
+    };
+}
+const INVENTORY_SAMPLE_LIMIT = 1000;
+const MANIFEST_CANDIDATE_LIMIT = 512;
+function emptyAreaCounts() {
+    return {
+        state: 0,
+        services: 0,
+        network: 0,
+        persistence: 0,
+        architecture: 0,
+        screens: 0,
+        components: 0,
+        navigation: 0,
+    };
+}
+async function shouldPruneDirectory(root, relativePath) {
+    const segments = relativePath.toLowerCase().split('/');
+    const name = segments.at(-1) ?? '';
+    if (/^(node_modules|vendor|pods|\.venv|\.gradle|\.dart_tool|\.next|\.nuxt|coverage)$/.test(name))
+        return true;
+    if (!/^(dist|build|out|target|bin|obj)$/.test(name))
+        return false;
+    const parent = dirname(join(root, relativePath));
+    const names = (await readdir(parent)).map((entry) => entry.toLowerCase());
+    if (names.some((entry) => /^(package\.json|pubspec\.yaml|pom\.xml|build\.gradle(?:\.kts)?)$|\.(csproj|fsproj|vbproj)$/.test(entry)))
+        return true;
+    if (segments.slice(0, -1).some((segment) => /^(src|lib|app|packages)$/.test(segment)))
+        return false;
+    return !['bin', 'obj'].includes(name);
+}
+function isCredentialDataPath(path) {
+    const segments = path.split('/');
+    const basename = segments.at(-1) ?? '';
+    if (/(^|\/)(\.env(?:\.[^/]*)?)(\/|$)/.test(path) ||
+        /\.(pem|key|p12|pfx|jks|keystore)$/.test(path) ||
+        /(^|\/)id_(rsa|dsa|ecdsa|ed25519)$/.test(path))
+        return true;
+    const parentIsSensitive = segments
+        .slice(0, -1)
+        .some((segment) => /^(?:secret|secrets|credential|credentials)$/i.test(segment));
+    return parentIsSensitive && /\.(json|ya?ml|toml|ini|conf|cfg|txt)$/i.test(basename);
+}
+async function detectStacks(root, manifestCandidates) {
+    const detected = [];
+    for (const candidate of manifestCandidates) {
+        const directory = dirname(join(root, candidate));
+        const packageManifest = candidate.toLowerCase().endsWith('package.json')
+            ? await readJsonManifest(join(root, candidate))
+            : null;
+        const dependencies = new Set([
+            ...Object.keys(packageManifest?.dependencies ?? {}),
+            ...Object.keys(packageManifest?.devDependencies ?? {}),
+        ]);
+        const relative = directory.slice(root.length + 1).replace(/\\/g, '/') || '.';
+        const prefix = relative === '.' ? '' : `${relative}/`;
+        if (candidate.toLowerCase().endsWith('pubspec.yaml')) {
+            const pubspec = await readBoundedText(join(root, candidate));
+            if (pubspec !== null && isFlutterManifest(pubspec))
+                detected.push({ stack: 'Flutter', evidence: `${prefix}pubspec.yaml declares Flutter` });
+        }
+        if (candidate.toLowerCase().endsWith('package.json') && dependencies.has('@nestjs/core'))
+            detected.push({ stack: 'Nest', evidence: `${prefix}package.json declares @nestjs/core` });
+        if (candidate.toLowerCase().endsWith('package.json') &&
+            (dependencies.has('react') || dependencies.has('react-dom')))
+            detected.push({ stack: 'React', evidence: `${prefix}package.json declares React` });
+        if (/build\.gradle(?:\.kts)?$/i.test(candidate)) {
+            const gradle = await readBoundedText(join(root, candidate));
+            if (gradle !== null && isSpringGradleManifest(gradle))
+                detected.push({ stack: 'Spring', evidence: `${candidate} declares Spring` });
+        }
+        if (candidate.toLowerCase().endsWith('pom.xml')) {
+            const pom = await readBoundedText(join(root, candidate));
+            if (pom !== null && isSpringManifest(pom))
+                detected.push({ stack: 'Spring', evidence: `${prefix}pom.xml declares Spring` });
+        }
+    }
+    return detected;
+}
+function meaningfulEntries(entries) {
+    return entries.filter((entry) => entry.name !== '.git');
+}
+async function readBoundedText(path, maxBytes = 1024 * 1024) {
+    try {
+        const info = await lstat(path);
+        if (!info.isFile() || info.isSymbolicLink() || info.size > maxBytes)
+            return null;
+        return await readFile(path, 'utf8');
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            'code' in error &&
+            error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+async function readJsonManifest(path) {
+    const text = await readBoundedText(path);
+    if (text === null)
+        return null;
+    try {
+        const value = JSON.parse(text);
+        return value !== null && typeof value === 'object'
+            ? value
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isFlutterManifest(text) {
+    return (/(^|\n)\s*(?:flutter|flutter_test|flutter_lints)\s*:/m.test(text) ||
+        /(^|\n)\s*sdk\s*:\s*flutter\s*$/m.test(text));
+}
+function isSpringGradleManifest(text) {
+    const declarations = text.replace(/\/\*[\s\S]*?\*\/|^\s*\/\/.*$/gm, '');
+    return /\bid\s*(?:\(\s*)?["']org\.springframework\.boot["']|\bapply\s+plugin\s*:\s*["']org\.springframework\.boot["']|["']org\.springframework(?:\.boot)?:[^"'\r\n]+["']/.test(declarations);
+}
+function isSpringManifest(text) {
+    return /org\.springframework|spring-boot-(?:starter|maven-plugin)|spring-boot-starter-parent/i.test(text);
+}
+async function assertNoRepositoryAncestor(path, runner) {
+    const target = resolve(path);
+    let current = target;
+    let checkedRepository = false;
+    while (true) {
+        try {
+            const info = await lstat(current);
+            if (info.isSymbolicLink())
+                throw new Error('Project path ancestry must not contain symbolic links');
+            if (!info.isDirectory())
+                throw new Error('Project path must be a real directory');
+            if (!checkedRepository) {
+                const result = await runner.run('git', ['rev-parse', '--show-toplevel'], { cwd: current });
+                if (result.exitCode === 0 &&
+                    resolve(result.stdout.trim()) !== (await canonicalPath(target))) {
+                    throw new Error('Refusing to initialize inside an existing parent repository');
+                }
+                checkedRepository = true;
+            }
+        }
+        catch (error) {
+            if (!(error instanceof Error &&
+                'code' in error &&
+                error.code === 'ENOENT'))
+                throw error;
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            return;
+        current = parent;
+    }
+}
+//# sourceMappingURL=project-intake.js.map

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',