proteum 2.5.4 → 2.5.6

package/tests/agents-utils.test.cjs

@@ -8,7 +8,11 @@ process.env.TS_NODE_PROJECT = path.join(coreRoot, 'cli', 'tsconfig.json');
 process.env.TS_NODE_TRANSPILE_ONLY = '1';
 require('ts-node/register/transpile-only');
 
-const { configureProjectAgentInstructions, resolveProjectAgentMonorepoRoot } = require('../cli/utils/agents.ts');
+const {
+    configureMonorepoProjectAgentInstructions,
+    configureProjectAgentInstructions,
+    resolveProjectAgentMonorepoRoot,
+} = require('../cli/utils/agents.ts');
 
 const writeFile = (filepath, content) => {
     fs.mkdirSync(path.dirname(filepath), { recursive: true });
@@ -271,7 +275,7 @@ test('monorepo configure writes root and app instruction files', () => {
     assert.match(fs.readFileSync(path.join(monorepoRoot, 'AGENTS.md'), 'utf8'), /## Agent Routing Contract/);
     assert.match(fs.readFileSync(path.join(monorepoRoot, 'AGENTS.md'), 'utf8'), /## Known Proteum Apps/);
     assert.match(fs.readFileSync(path.join(monorepoRoot, 'AGENTS.md'), 'utf8'), /apps\/product/);
-    assert.match(fs.readFileSync(path.join(monorepoRoot, 'AGENTS.md'), 'utf8'), /Do not start `npx proteum dev` from this root/);
+    assert.match(fs.readFileSync(path.join(monorepoRoot, 'AGENTS.md'), 'utf8'), /Eligible Proteum commands run across the apps below/);
     assert.match(fs.readFileSync(path.join(monorepoRoot, 'AGENTS.md'), 'utf8'), /Worktree Preflight/);
     assert.match(fs.readFileSync(path.join(monorepoRoot, 'CODING_STYLE.md'), 'utf8'), /## Source: CODING_STYLE\.md/);
     assert.match(fs.readFileSync(path.join(monorepoRoot, 'DOCUMENTATION.md'), 'utf8'), /## Source: DOCUMENTATION\.md/);
@@ -291,7 +295,7 @@ test('monorepo configure writes root and app instruction files', () => {
     const appAgentsContent = fs.readFileSync(path.join(appRoot, 'AGENTS.md'), 'utf8');
     assert.match(appAgentsContent, /## Agent Routing Contract/);
     assert.doesNotMatch(appAgentsContent, /## Known Proteum Apps/);
-    assert.doesNotMatch(appAgentsContent, /Do not start `npx proteum dev` from this root/);
+    assert.doesNotMatch(appAgentsContent, /Eligible Proteum commands run across the apps below/);
     assert.match(fs.readFileSync(path.join(appRoot, 'client', 'AGENTS.md'), 'utf8'), /## Source: client\/AGENTS\.md/);
     assertClaudeSymlink(appRoot);
     assertClaudeSymlink(appRoot, 'client');
@@ -302,6 +306,62 @@ test('monorepo configure writes root and app instruction files', () => {
     assert.equal(result.removed.some((entry) => entry.endsWith('/apps/product/CODING_STYLE.md')), true);
 });
 
+test('monorepo-wide configure writes shared root once and all app instruction files', () => {
+    const coreRoot = createCoreFixture();
+    const monorepoRoot = makeTempRoot();
+    const productRoot = path.join(monorepoRoot, 'apps', 'product');
+    const websiteRoot = path.join(monorepoRoot, 'apps', 'website');
+
+    for (const appRoot of [productRoot, websiteRoot]) {
+        fs.mkdirSync(path.join(appRoot, 'client'), { recursive: true });
+        fs.mkdirSync(path.join(appRoot, 'server'), { recursive: true });
+        writeFile(path.join(appRoot, 'package.json'), '{"name":"fixture"}\n');
+        writeFile(path.join(appRoot, 'identity.config.ts'), 'export default {};\n');
+        writeFile(path.join(appRoot, 'proteum.config.ts'), 'export default {};\n');
+    }
+
+    const result = configureMonorepoProjectAgentInstructions({
+        appRoots: [websiteRoot, productRoot],
+        coreRoot,
+        monorepoRoot,
+    });
+    const rootAgentsContent = fs.readFileSync(path.join(monorepoRoot, 'AGENTS.md'), 'utf8');
+
+    assert.equal(result.mode, 'monorepo');
+    assert.deepEqual(result.appRoots, [productRoot, websiteRoot]);
+    assert.match(rootAgentsContent, /apps\/product/);
+    assert.match(rootAgentsContent, /apps\/website/);
+    assert.doesNotMatch(rootAgentsContent, /current configured app/);
+    assert.match(fs.readFileSync(path.join(productRoot, 'AGENTS.md'), 'utf8'), /## Agent Routing Contract/);
+    assert.match(fs.readFileSync(path.join(websiteRoot, 'AGENTS.md'), 'utf8'), /## Agent Routing Contract/);
+    assert.equal(fs.existsSync(path.join(productRoot, 'CODING_STYLE.md')), false);
+    assert.equal(fs.existsSync(path.join(websiteRoot, 'CODING_STYLE.md')), false);
+});
+
+test('monorepo-wide configure dedupes app roots and blocked paths', () => {
+    const coreRoot = createCoreFixture();
+    const monorepoRoot = makeTempRoot();
+    const productRoot = path.join(monorepoRoot, 'apps', 'product');
+    const blockedClaudePath = path.join(productRoot, 'CLAUDE.md');
+
+    fs.mkdirSync(path.join(productRoot, 'client'), { recursive: true });
+    fs.mkdirSync(path.join(productRoot, 'server'), { recursive: true });
+    writeFile(path.join(productRoot, 'package.json'), '{"name":"fixture"}\n');
+    writeFile(path.join(productRoot, 'identity.config.ts'), 'export default {};\n');
+    writeFile(path.join(productRoot, 'proteum.config.ts'), 'export default {};\n');
+    writeFile(blockedClaudePath, '# Local Claude Notes\n');
+
+    const result = configureMonorepoProjectAgentInstructions({
+        appRoots: [productRoot, productRoot],
+        coreRoot,
+        dryRun: true,
+        monorepoRoot,
+    });
+
+    assert.deepEqual(result.appRoots, [productRoot]);
+    assert.equal(result.blocked.filter((entry) => entry === blockedClaudePath).length, 1);
+});
+
 test('monorepo configure preserves local app-root documents', () => {
     const coreRoot = createCoreFixture();
     const monorepoRoot = makeTempRoot();

package/tests/cli-mcp-command.test.cjs

@@ -16,8 +16,32 @@ const writeFile = (filepath, content) => {
 
 const createProteumApp = (appRoot, { routerPort = 3020 } = {}) => {
     writeFile(path.join(appRoot, 'package.json'), '{"name":"fixture"}\n');
-    writeFile(path.join(appRoot, 'identity.config.ts'), 'export default {};\n');
+    writeFile(
+        path.join(appRoot, 'identity.config.ts'),
+        `export default {
+    name: 'Product',
+    identifier: 'ProductApp',
+    description: 'Fixture app',
+    author: { name: 'Test', url: 'https://example.com', email: 'test@example.com' },
+    language: 'en',
+    maincolor: '#000000',
+    web: {
+        title: 'Product',
+        titleSuffix: 'Product',
+        fullTitle: 'Product',
+        description: 'Fixture app',
+        version: '1.0.0',
+        metas: {},
+        jsonld: {},
+    },
+};
+`,
+    );
     writeFile(path.join(appRoot, 'proteum.config.ts'), 'export default {};\n');
+    writeFile(
+        path.join(appRoot, '.env'),
+        `ENV_NAME=local\nENV_PROFILE=dev\nPORT=${routerPort}\nURL=http://localhost:${routerPort}\nURL_INTERNAL=http://localhost:${routerPort}\n`,
+    );
     fs.mkdirSync(path.join(appRoot, 'client'), { recursive: true });
     fs.mkdirSync(path.join(appRoot, 'server'), { recursive: true });
     writeFile(
@@ -293,7 +317,7 @@ test('explain help describes compact section summaries', () => {
     assert.match(output, /Explicit section flags summarize those sections by default/);
 });
 
-test('runtime status from a monorepo wrapper returns app candidates instead of treating wrapper as app', () => {
+test('runtime status from a monorepo wrapper aggregates app runtime status', () => {
     const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-cli-wrapper-'));
     createProteumApp(path.join(repoRoot, 'apps', 'product'));
 
@@ -303,18 +327,38 @@ test('runtime status from a monorepo wrapper returns app candidates instead of t
     });
     const payload = JSON.parse(result.stdout);
 
-    assert.equal(result.status, 1);
-    assert.equal(payload.ok, false);
-    assert.equal(payload.data.appCandidates.length, 1);
-    assert.match(payload.nextActions[0].command, /cd "apps\/product"/);
-    assert.match(payload.nextActions[0].command, /npx proteum runtime status/);
+    assert.equal(result.status, 0, result.stderr);
+    assert.equal(payload.ok, true);
+    assert.equal(payload.data.apps.length, 1);
+    assert.equal(payload.data.apps[0].relativeAppRoot, 'apps/product');
+    assert.equal(payload.data.apps[0].ok, true);
+    assert.equal(payload.data.apps[0].json.data.appRoot, fs.realpathSync(path.join(repoRoot, 'apps', 'product')));
 });
 
-test('dev from a monorepo wrapper returns exact app-root start command', () => {
+test('dev list from a monorepo wrapper aggregates app session lists', () => {
     const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-cli-dev-wrapper-'));
     createProteumApp(path.join(repoRoot, 'apps', 'product'));
 
-    const result = spawnSync(process.execPath, [cliBin, 'dev', 'list'], {
+    const result = spawnSync(process.execPath, [cliBin, 'dev', 'list', '--json'], {
+        cwd: repoRoot,
+        encoding: 'utf8',
+    });
+    const payload = JSON.parse(result.stdout);
+
+    assert.equal(result.status, 0, result.stderr);
+    assert.equal(payload.ok, true);
+    assert.equal(payload.data.apps.length, 1);
+    assert.equal(payload.data.apps[0].relativeAppRoot, 'apps/product');
+    assert.equal(payload.data.apps[0].json.sessions.length, 0);
+});
+
+test('monorepo command fan-out continues after app command failures', () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-cli-dev-wrapper-failure-'));
+    createProteumApp(path.join(repoRoot, 'apps', 'product'));
+    createProteumApp(path.join(repoRoot, 'apps', 'website'));
+    writeFile(path.join(repoRoot, 'apps', 'website', 'identity.config.ts'), 'export default {};\n');
+
+    const result = spawnSync(process.execPath, [cliBin, 'dev', 'list', '--json'], {
         cwd: repoRoot,
         encoding: 'utf8',
     });
@@ -322,8 +366,13 @@ test('dev from a monorepo wrapper returns exact app-root start command', () => {
 
     assert.equal(result.status, 1);
     assert.equal(payload.ok, false);
-    assert.match(payload.nextActions[0].command, /cd "apps\/product"/);
-    assert.match(payload.nextActions[0].command, /npx proteum dev --session-file/);
+    assert.deepEqual(
+        payload.data.apps.map((app) => app.relativeAppRoot),
+        ['apps/product', 'apps/website'],
+    );
+    assert.equal(payload.data.apps[0].ok, true);
+    assert.equal(payload.data.apps[1].ok, false);
+    assert.match(payload.data.apps[1].stdout, /Invalid author/);
 });
 
 test('runtime status manifest guard points to explain manifest', () => {

package/tests/mcp.test.cjs

@@ -99,8 +99,53 @@ const createManifest = (appRoot, overrides = {}) => ({
 
 const writeProteumAppFixture = (appRoot, manifestOverrides = {}) => {
     writeFile(path.join(appRoot, 'package.json'), '{"name":"fixture"}\n');
+    writeFile(path.join(appRoot, 'package-lock.json'), '{"lockfileVersion":3}\n');
+    writeFile(
+        path.join(appRoot, '.env'),
+        [
+            'ENV_NAME=local',
+            'ENV_PROFILE=dev',
+            `PORT=${manifestOverrides.routerPort || 3104}`,
+            `URL=http://localhost:${manifestOverrides.routerPort || 3104}`,
+            `URL_INTERNAL=http://localhost:${manifestOverrides.routerPort || 3104}`,
+            '',
+        ].join('\n'),
+    );
+    fs.mkdirSync(path.join(appRoot, 'node_modules'), { recursive: true });
+    writeFile(path.join(appRoot, 'identity.config.ts'), 'export default {};\n');
+    writeFile(path.join(appRoot, 'proteum.config.ts'), 'export default {};\n');
+    writeFile(path.join(appRoot, 'client', 'AGENTS.md'), '# Client\n');
+    writeFile(path.join(appRoot, 'client', 'pages', 'AGENTS.md'), '# Pages\n');
+    writeFile(path.join(appRoot, 'server', 'AGENTS.md'), '# Server\n');
+    writeFile(path.join(appRoot, 'server', 'routes', 'AGENTS.md'), '# Routes\n');
+    writeFile(path.join(appRoot, 'AGENTS.md'), '# App\n');
+    writeFile(path.join(appRoot, 'diagnostics.md'), '# Diagnostics\n');
+    writeFile(path.join(appRoot, '.proteum', 'manifest.json'), JSON.stringify(createManifest(appRoot, manifestOverrides), null, 2));
+};
+
+const writeFreshCopyFixture = (appRoot, manifestOverrides = {}) => {
+    writeFile(path.join(appRoot, 'package.json'), '{"name":"fresh-copy"}\n');
+    writeFile(path.join(appRoot, 'package-lock.json'), '{"lockfileVersion":3}\n');
+    writeFile(
+        path.join(appRoot, '.env.example'),
+        [
+            'ENV_NAME=local',
+            'ENV_PROFILE=dev',
+            'PORT=3020',
+            'URL=http://localhost:3020',
+            'URL_INTERNAL=http://localhost:3020',
+            'DATABASE_URL=mysql://user:pass@localhost:3306/app',
+            '',
+        ].join('\n'),
+    );
     writeFile(path.join(appRoot, 'identity.config.ts'), 'export default {};\n');
     writeFile(path.join(appRoot, 'proteum.config.ts'), 'export default {};\n');
+    writeFile(
+        path.join(appRoot, 'prisma', 'schema.prisma'),
+        ['generator client {', '  provider = "prisma-client-js"', '  output = "../var/prisma"', '}', '', 'datasource db {', '  provider = "mysql"', '}'].join(
+            '\n',
+        ),
+    );
     writeFile(path.join(appRoot, 'client', 'AGENTS.md'), '# Client\n');
     writeFile(path.join(appRoot, 'client', 'pages', 'AGENTS.md'), '# Pages\n');
     writeFile(path.join(appRoot, 'server', 'AGENTS.md'), '# Server\n');
@@ -700,7 +745,10 @@ test('machine MCP router resolves projects by cwd and bootstraps workflow withou
     assert.equal(forwardedCall.name, 'workflow_start');
     assert.deepEqual(forwardedCall.arguments, { route: '/domains', task: 'read-only runtime health pass' });
     assert.equal(workflowPayload.data.project.projectId, productMachineRecord.projectId);
-    assert.equal(workflowPayload.nextActions[0].toolArgs.projectId, productMachineRecord.projectId);
+    assert.equal(
+        workflowPayload.nextActions.find((action) => action.tool === 'diagnose').toolArgs.projectId,
+        productMachineRecord.projectId,
+    );
 
     await client.close();
     await server.close();
@@ -785,6 +833,55 @@ test('machine MCP router resolves offline monorepo app candidates before dev is
     await server.close();
 });
 
+test('machine MCP workflow_start reports fresh-copy setup blockers before dev start', async (t) => {
+    const previousRegistryDir = process.env.PROTEUM_MACHINE_DEV_SESSION_DIR;
+    const registryDir = fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-machine-fresh-copy-registry-'));
+    process.env.PROTEUM_MACHINE_DEV_SESSION_DIR = registryDir;
+    t.onTestFinished(() => {
+        if (previousRegistryDir === undefined) delete process.env.PROTEUM_MACHINE_DEV_SESSION_DIR;
+        else process.env.PROTEUM_MACHINE_DEV_SESSION_DIR = previousRegistryDir;
+    });
+
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-machine-fresh-copy-'));
+    const appRoot = path.join(repoRoot, 'apps', 'product');
+    writeFreshCopyFixture(appRoot, {
+        identifier: 'FreshCopyApp',
+        name: 'Fresh Copy',
+        routerPort: 3022,
+    });
+
+    const server = createProteumMachineMcpServer({ version: 'test' });
+    const client = new Client({ name: 'machine-mcp-test', version: '1.0.0' });
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+
+    await server.connect(serverTransport);
+    await client.connect(clientTransport);
+
+    const workflow = await client.callTool({
+        name: 'workflow_start',
+        arguments: { cwd: appRoot, task: 'prepare fresh copy' },
+    });
+    const payload = JSON.parse(workflow.content[0].text);
+    const actionLabels = payload.nextActions.map((action) => action.label);
+
+    assert.equal(payload.ok, true);
+    assert.equal(payload.data.readiness.state, 'blocked');
+    assert.equal(payload.data.readiness.env.app.present, false);
+    assert.equal(payload.data.readiness.dependencies.nodeModulesPresent, false);
+    assert.equal(payload.data.readiness.database.detected, true);
+    assert.equal(payload.data.readiness.database.generatedClientPresent, false);
+    assert.equal(actionLabels.includes('Copy App Env Example'), true);
+    assert.equal(actionLabels.includes('Install Dependencies'), true);
+    assert.equal(actionLabels.includes('Generate Prisma Client'), true);
+    assert.equal(actionLabels.includes('Start Dev'), true);
+    assert.match(payload.nextActions.find((action) => action.label === 'Install Dependencies').command, /npm install/);
+    assert.match(payload.nextActions.find((action) => action.label === 'Generate Prisma Client').command, /prisma generate/);
+    assert.doesNotMatch(workflow.content[0].text, /mysql:\/\/user:pass/);
+
+    await client.close();
+    await server.close();
+});
+
 test('machine MCP workflow_start blocks offline unbootstrapped Codex worktrees', async (t) => {
     const previousRegistryDir = process.env.PROTEUM_MACHINE_DEV_SESSION_DIR;
     const registryDir = fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-machine-worktree-offline-'));

package/tests/worktree-bootstrap.test.cjs

@@ -1,4 +1,5 @@
 const assert = require('node:assert/strict');
+const { spawnSync } = require('node:child_process');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
@@ -11,6 +12,8 @@ require('ts-node/register/transpile-only');
 const {
     createWorktreeBootstrapDiagnostics,
     getWorktreeBootstrapStatus,
+    runMonorepoWorktreeBootstrapCreate,
+    runMonorepoWorktreeBootstrapInit,
     runWorktreeBootstrapInit,
     worktreeBootstrapMarkerRelativePath,
 } = require('../cli/runtime/worktreeBootstrap.ts');
@@ -20,6 +23,12 @@ const writeFile = (filepath, content) => {
     fs.writeFileSync(filepath, content);
 };
 
+const runGit = (cwd, args) => {
+    const result = spawnSync('git', args, { cwd, encoding: 'utf8' });
+
+    assert.equal(result.status, 0, `${result.stderr}\n${result.stdout}`);
+};
+
 const createCodexAppRoot = () => {
     const root = fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-worktree-bootstrap-'));
     const appRoot = path.join(root, '.codex', 'worktrees', 'fixture-app');
@@ -38,6 +47,19 @@ const writeBootstrapFixture = (appRoot, { env = true, manifest = true, nodeModul
     if (nodeModules) fs.mkdirSync(path.join(appRoot, 'node_modules'), { recursive: true });
 };
 
+const writeProteumAppRootFixture = (appRoot, { env = true } = {}) => {
+    writeFile(path.join(appRoot, 'package.json'), '{"name":"fixture"}\n');
+    writeFile(path.join(appRoot, 'identity.config.ts'), 'export default {};\n');
+    writeFile(path.join(appRoot, 'proteum.config.ts'), 'export default {};\n');
+    writeFile(path.join(appRoot, 'AGENTS.md'), '# Agents\n');
+    if (env) writeFile(path.join(appRoot, '.env'), 'PORT=3020\n');
+    writeFile(path.join(appRoot, '.proteum', 'manifest.json'), '{"version":10}\n');
+    fs.mkdirSync(path.join(appRoot, 'client'), { recursive: true });
+    fs.mkdirSync(path.join(appRoot, 'server'), { recursive: true });
+    writeFile(path.join(appRoot, 'client', '.keep'), '');
+    writeFile(path.join(appRoot, 'server', '.keep'), '');
+};
+
 const noOpRefresh = async () => ({ stdout: '', stderr: '', summary: 'refresh ok' });
 const noOpRuntime = async () => ({ stdout: '', stderr: '', summary: 'runtime ok' });
 const noOpDeps = async () => {};
@@ -228,6 +250,82 @@ test('worktree bootstrap falls back to source app env for missing workspace root
     assert.equal(result.status.blocking, false);
 });
 
+test('monorepo worktree bootstrap initializes every app and dedupes shared dependency install', async () => {
+    const targetRepoRoot = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-worktree-monorepo-all-')), '.codex', 'worktrees', 'fixture-repo');
+    const sourceRepoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-worktree-monorepo-source-'));
+    const targetProductRoot = path.join(targetRepoRoot, 'apps', 'product');
+    const targetWebsiteRoot = path.join(targetRepoRoot, 'apps', 'website');
+
+    writeFile(path.join(targetRepoRoot, 'package.json'), '{"workspaces":["apps/*"]}\n');
+    writeFile(path.join(targetRepoRoot, 'package-lock.json'), '{"lockfileVersion":3}\n');
+    writeProteumAppRootFixture(targetProductRoot, { env: false });
+    writeProteumAppRootFixture(targetWebsiteRoot, { env: false });
+
+    writeFile(path.join(sourceRepoRoot, 'package.json'), '{"workspaces":["apps/*"]}\n');
+    writeFile(path.join(sourceRepoRoot, 'package-lock.json'), '{"lockfileVersion":3}\n');
+    writeProteumAppRootFixture(path.join(sourceRepoRoot, 'apps', 'product'));
+    writeProteumAppRootFixture(path.join(sourceRepoRoot, 'apps', 'website'));
+
+    const installRoots = [];
+    const result = await runMonorepoWorktreeBootstrapInit({
+        coreRoot,
+        monorepoRoot: targetRepoRoot,
+        proteumVersion: 'test',
+        runDependencies: async (installRoot) => {
+            installRoots.push(installRoot);
+            fs.mkdirSync(path.join(installRoot, 'node_modules'), { recursive: true });
+        },
+        runRefresh: noOpRefresh,
+        runRuntimeStatus: noOpRuntime,
+        source: sourceRepoRoot,
+    });
+
+    assert.equal(result.ok, true);
+    assert.equal(result.apps.length, 2);
+    assert.deepEqual(installRoots, [fs.realpathSync(targetRepoRoot)]);
+    assert.equal(fs.existsSync(path.join(targetProductRoot, worktreeBootstrapMarkerRelativePath)), true);
+    assert.equal(fs.existsSync(path.join(targetWebsiteRoot, worktreeBootstrapMarkerRelativePath)), true);
+    assert.equal(fs.readFileSync(path.join(targetProductRoot, '.env'), 'utf8'), 'PORT=3020\n');
+    assert.equal(fs.readFileSync(path.join(targetWebsiteRoot, '.env'), 'utf8'), 'PORT=3020\n');
+});
+
+test('monorepo worktree create adds one git worktree and bootstraps target apps', async () => {
+    const sourceRepoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-worktree-create-source-'));
+    const targetRepoRoot = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-worktree-create-target-')), 'repo-worktree');
+
+    writeFile(path.join(sourceRepoRoot, 'package.json'), '{"workspaces":["apps/*"]}\n');
+    writeFile(path.join(sourceRepoRoot, 'package-lock.json'), '{"lockfileVersion":3}\n');
+    writeProteumAppRootFixture(path.join(sourceRepoRoot, 'apps', 'product'));
+    writeProteumAppRootFixture(path.join(sourceRepoRoot, 'apps', 'website'));
+    runGit(sourceRepoRoot, ['init']);
+    runGit(sourceRepoRoot, ['config', 'user.email', 'test@example.com']);
+    runGit(sourceRepoRoot, ['config', 'user.name', 'Test']);
+    runGit(sourceRepoRoot, ['add', '.']);
+    runGit(sourceRepoRoot, ['commit', '-m', 'init']);
+
+    const installRoots = [];
+    const result = await runMonorepoWorktreeBootstrapCreate({
+        branch: 'test/monorepo-create',
+        coreRoot,
+        monorepoRoot: sourceRepoRoot,
+        proteumVersion: 'test',
+        runDependencies: async (installRoot) => {
+            installRoots.push(installRoot);
+            fs.mkdirSync(path.join(installRoot, 'node_modules'), { recursive: true });
+        },
+        runRefresh: noOpRefresh,
+        runRuntimeStatus: noOpRuntime,
+        targetRepoRoot,
+    });
+
+    assert.equal(result.targetRepoRoot, targetRepoRoot);
+    assert.equal(result.worktreeBootstrap.ok, true);
+    assert.equal(result.worktreeBootstrap.apps.length, 2);
+    assert.deepEqual(installRoots, [fs.realpathSync(targetRepoRoot)]);
+    assert.equal(fs.existsSync(path.join(targetRepoRoot, 'apps', 'product', worktreeBootstrapMarkerRelativePath)), true);
+    assert.equal(fs.existsSync(path.join(targetRepoRoot, 'apps', 'website', worktreeBootstrapMarkerRelativePath)), true);
+});
+
 test('worktree bootstrap detects missing env manifest node_modules and version changes', async () => {
     const appRoot = createCodexAppRoot();
     writeBootstrapFixture(appRoot);