proteum 2.5.5 → 2.5.7

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 });
@@ -34,8 +38,9 @@ const pathEntryExists = (filepath) => {
 
 const makeTempRoot = () => fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-agents-'));
 
-const createCoreFixture = () => {
-    const root = makeTempRoot();
+const normalizePath = (value) => value.replace(/\\/g, '/');
+
+const createCoreFixture = (root = makeTempRoot()) => {
     const agentsRoot = path.join(root, 'agents', 'project');
 
     writeFile(path.join(agentsRoot, 'AGENTS.md'), '# Root Contract\n\n- Root rule\n');
@@ -57,6 +62,20 @@ const createCoreFixture = () => {
     return root;
 };
 
+const expectedSourceMapPath = ({ coreRoot, instructionRoot, projectPath }) =>
+    normalizePath(path.relative(instructionRoot, path.join(coreRoot, 'agents', 'project', projectPath)));
+
+const assertSourceMapPath = ({ content, coreRoot, instructionRoot, label, projectPath }) => {
+    assert.equal(
+        content.includes(`- ${label}: ${expectedSourceMapPath({ coreRoot, instructionRoot, projectPath })}`),
+        true,
+    );
+};
+
+const assertNoAbsoluteCoreSourceMapPath = ({ content, coreRoot }) => {
+    assert.equal(content.includes(normalizePath(path.join(coreRoot, 'agents', 'project'))), false);
+};
+
 const createAppFixture = () => {
     const appRoot = makeTempRoot();
 
@@ -169,6 +188,53 @@ test('standalone configure creates tracked instruction files with routing contra
     assert.doesNotMatch(gitignoreContent, /^\/DOCUMENTATION\.md$/m);
 });
 
+test('standalone configure writes install-relative source map fallbacks', () => {
+    const appRoot = createAppFixture();
+    const coreRoot = createCoreFixture(path.join(appRoot, 'node_modules', 'proteum'));
+    const result = configureProjectAgentInstructions({ appRoot, coreRoot });
+    const agentsContent = fs.readFileSync(path.join(appRoot, 'AGENTS.md'), 'utf8');
+
+    assert.equal(result.blocked.length, 0);
+    assertSourceMapPath({
+        content: agentsContent,
+        coreRoot,
+        instructionRoot: appRoot,
+        label: 'Root contract fallback',
+        projectPath: 'AGENTS.md',
+    });
+    assertSourceMapPath({
+        content: agentsContent,
+        coreRoot,
+        instructionRoot: appRoot,
+        label: 'Documentation fallback',
+        projectPath: 'DOCUMENTATION.md',
+    });
+    assertNoAbsoluteCoreSourceMapPath({ content: agentsContent, coreRoot });
+    assert.match(agentsContent, /Root contract fallback: node_modules\/proteum\/agents\/project\/AGENTS\.md/);
+});
+
+test('standalone configure source map prefers project install over active external core', () => {
+    const activeCoreRoot = createCoreFixture();
+    const appRoot = createAppFixture();
+    createCoreFixture(path.join(appRoot, 'node_modules', 'proteum'));
+
+    configureProjectAgentInstructions({ appRoot, coreRoot: activeCoreRoot });
+
+    const agentsContent = fs.readFileSync(path.join(appRoot, 'AGENTS.md'), 'utf8');
+    assert.match(agentsContent, /Root contract fallback: node_modules\/proteum\/agents\/project\/AGENTS\.md/);
+    assert.equal(
+        agentsContent.includes(
+            `Root contract fallback: ${expectedSourceMapPath({
+                coreRoot: activeCoreRoot,
+                instructionRoot: appRoot,
+                projectPath: 'AGENTS.md',
+            })}`,
+        ),
+        false,
+    );
+    assertNoAbsoluteCoreSourceMapPath({ content: agentsContent, coreRoot: activeCoreRoot });
+});
+
 test('configure preserves project content outside the managed section', () => {
     const coreRoot = createCoreFixture();
     const appRoot = createAppFixture();
@@ -271,7 +337,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 +357,23 @@ 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/);
+    assertSourceMapPath({
+        content: fs.readFileSync(path.join(monorepoRoot, 'AGENTS.md'), 'utf8'),
+        coreRoot,
+        instructionRoot: monorepoRoot,
+        label: 'Root contract fallback',
+        projectPath: 'AGENTS.md',
+    });
+    assertSourceMapPath({
+        content: appAgentsContent,
+        coreRoot,
+        instructionRoot: appRoot,
+        label: 'Root contract fallback',
+        projectPath: 'AGENTS.md',
+    });
+    assertNoAbsoluteCoreSourceMapPath({ content: fs.readFileSync(path.join(monorepoRoot, 'AGENTS.md'), 'utf8'), coreRoot });
+    assertNoAbsoluteCoreSourceMapPath({ content: appAgentsContent, coreRoot });
     assert.match(fs.readFileSync(path.join(appRoot, 'client', 'AGENTS.md'), 'utf8'), /## Source: client\/AGENTS\.md/);
     assertClaudeSymlink(appRoot);
     assertClaudeSymlink(appRoot, 'client');
@@ -302,6 +384,84 @@ 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 configure source map uses workspace install from root and nested apps', () => {
+    const activeCoreRoot = createCoreFixture();
+    const monorepoRoot = makeTempRoot();
+    const appRoot = path.join(monorepoRoot, 'apps', 'product');
+
+    createCoreFixture(path.join(monorepoRoot, 'node_modules', 'proteum'));
+    fs.mkdirSync(path.join(monorepoRoot, '.git'));
+    fs.mkdirSync(path.join(appRoot, 'client'), { recursive: true });
+    writeFile(path.join(appRoot, 'package.json'), '{"name":"product"}\n');
+    writeFile(path.join(appRoot, 'identity.config.ts'), 'export default {};\n');
+    writeFile(path.join(appRoot, 'proteum.config.ts'), 'export default {};\n');
+
+    configureProjectAgentInstructions({ appRoot, coreRoot: activeCoreRoot, monorepoRoot });
+
+    const rootAgentsContent = fs.readFileSync(path.join(monorepoRoot, 'AGENTS.md'), 'utf8');
+    const appAgentsContent = fs.readFileSync(path.join(appRoot, 'AGENTS.md'), 'utf8');
+    assert.match(rootAgentsContent, /Root contract fallback: node_modules\/proteum\/agents\/project\/AGENTS\.md/);
+    assert.match(appAgentsContent, /Root contract fallback: \.\.\/\.\.\/node_modules\/proteum\/agents\/project\/AGENTS\.md/);
+    assertNoAbsoluteCoreSourceMapPath({ content: rootAgentsContent, coreRoot: activeCoreRoot });
+    assertNoAbsoluteCoreSourceMapPath({ content: appAgentsContent, coreRoot: activeCoreRoot });
+});
+
+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/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);