1284 lines
47 KiB
TypeScript
1284 lines
47 KiB
TypeScript
import { AGENT_BLOCK_CLOSE, AGENT_BLOCK_OPEN } from '@shared/constants/agentBlocks';
|
|
import { EventEmitter } from 'events';
|
|
import * as fs from 'fs';
|
|
import * as os from 'os';
|
|
import * as path from 'path';
|
|
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
|
|
|
|
const hoisted = vi.hoisted(() => ({
|
|
paths: {
|
|
claudeRoot: '',
|
|
teamsBase: '',
|
|
tasksBase: '',
|
|
},
|
|
}));
|
|
|
|
let tempClaudeRoot = '';
|
|
let tempTeamsBase = '';
|
|
let tempTasksBase = '';
|
|
|
|
vi.mock('@main/services/team/ClaudeBinaryResolver', () => ({
|
|
ClaudeBinaryResolver: { resolve: vi.fn() },
|
|
}));
|
|
|
|
vi.mock('@main/utils/childProcess', () => ({
|
|
execCli: vi.fn(async (_binaryPath: string | null, args: string[]) => {
|
|
if (args[0] === '-e' && args[1]?.includes('process.execPath')) {
|
|
return {
|
|
stdout: JSON.stringify({ execPath: process.execPath, version: process.versions.node }),
|
|
stderr: '',
|
|
};
|
|
}
|
|
if (args.includes('model') && args.includes('list')) {
|
|
return {
|
|
stdout: JSON.stringify({
|
|
schemaVersion: 1,
|
|
providers: {
|
|
anthropic: {
|
|
defaultModel: 'opus[1m]',
|
|
models: [
|
|
{ id: 'opus', label: 'Opus 4.7', description: 'Anthropic default family alias' },
|
|
{
|
|
id: 'opus[1m]',
|
|
label: 'Opus 4.7 (1M)',
|
|
description: 'Anthropic long-context default',
|
|
},
|
|
],
|
|
},
|
|
codex: {
|
|
defaultModel: 'gpt-5.4',
|
|
models: [{ id: 'gpt-5.4', label: 'GPT-5.4', description: 'Codex default' }],
|
|
},
|
|
gemini: {
|
|
defaultModel: 'gemini-2.5-pro',
|
|
models: [{ id: 'gemini-2.5-pro', label: 'Gemini 2.5 Pro', description: 'Default' }],
|
|
},
|
|
},
|
|
}),
|
|
stderr: '',
|
|
};
|
|
}
|
|
if (args.includes('runtime') && args.includes('status')) {
|
|
return {
|
|
stdout: JSON.stringify({
|
|
providers: {
|
|
codex: {
|
|
runtimeCapabilities: {
|
|
modelCatalog: { dynamic: false, source: 'runtime' },
|
|
reasoningEffort: {
|
|
supported: true,
|
|
values: ['low', 'medium', 'high'],
|
|
configPassthrough: false,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}),
|
|
stderr: '',
|
|
};
|
|
}
|
|
return { stdout: '', stderr: '' };
|
|
}),
|
|
spawnCli: vi.fn(),
|
|
killProcessTree: vi.fn(),
|
|
}));
|
|
|
|
vi.mock('@main/utils/shellEnv', async (importOriginal) => {
|
|
const actual = await importOriginal<typeof import('@main/utils/shellEnv')>();
|
|
return {
|
|
...actual,
|
|
getCachedShellEnv: () => ({ PATH: process.env.PATH ?? '', HOME: hoisted.paths.claudeRoot }),
|
|
getShellPreferredHome: () => hoisted.paths.claudeRoot || actual.getShellPreferredHome(),
|
|
resolveInteractiveShellEnv: vi.fn(async () => ({
|
|
PATH: process.env.PATH ?? '',
|
|
HOME: hoisted.paths.claudeRoot,
|
|
})),
|
|
};
|
|
});
|
|
|
|
vi.mock('@main/utils/pathDecoder', async (importOriginal) => {
|
|
const actual = await importOriginal<typeof import('@main/utils/pathDecoder')>();
|
|
return {
|
|
...actual,
|
|
getAutoDetectedClaudeBasePath: () => hoisted.paths.claudeRoot,
|
|
getClaudeBasePath: () => hoisted.paths.claudeRoot,
|
|
getTeamsBasePath: () => hoisted.paths.teamsBase,
|
|
getTasksBasePath: () => hoisted.paths.tasksBase,
|
|
};
|
|
});
|
|
|
|
import { ClaudeBinaryResolver } from '@main/services/team/ClaudeBinaryResolver';
|
|
import { TeamRuntimeAdapterRegistry } from '@main/services/team/runtime/TeamRuntimeAdapter';
|
|
import {
|
|
buildAddMemberSpawnMessage,
|
|
buildRestartMemberSpawnMessage,
|
|
TeamProvisioningService,
|
|
} from '@main/services/team/TeamProvisioningService';
|
|
import { execCli, spawnCli } from '@main/utils/childProcess';
|
|
import { setAppDataBasePath } from '@main/utils/pathDecoder';
|
|
|
|
function createFakeChild() {
|
|
const writeSpy = vi.fn((_data: unknown, cb?: (err?: Error | null) => void) => {
|
|
if (typeof cb === 'function') cb(null);
|
|
return true;
|
|
});
|
|
const endSpy = vi.fn();
|
|
const child = Object.assign(new EventEmitter(), {
|
|
pid: 12345,
|
|
stdin: { writable: true, write: writeSpy, end: endSpy },
|
|
stdout: new EventEmitter(),
|
|
stderr: new EventEmitter(),
|
|
kill: vi.fn(),
|
|
});
|
|
return { child, writeSpy };
|
|
}
|
|
|
|
function extractPromptFromBootstrapFile(callIndex = 0): string {
|
|
const args = vi.mocked(spawnCli).mock.calls[callIndex]?.[1] as string[] | undefined;
|
|
const promptFlagIndex = args?.indexOf('--team-bootstrap-user-prompt-file') ?? -1;
|
|
const promptPath = promptFlagIndex >= 0 ? args?.[promptFlagIndex + 1] : null;
|
|
if (!promptPath) {
|
|
throw new Error('Failed to extract bootstrap prompt file path from spawn args');
|
|
}
|
|
return fs.readFileSync(promptPath, 'utf8');
|
|
}
|
|
|
|
function extractBootstrapSpec(callIndex = 0): {
|
|
mode?: string;
|
|
team?: { name?: string; cwd?: string };
|
|
lead?: { permissionSeedTools?: string[] };
|
|
members?: Array<Record<string, unknown>>;
|
|
launch?: { bootstrapTimeoutMs?: number; continueOnPartialFailure?: boolean };
|
|
} {
|
|
const args = vi.mocked(spawnCli).mock.calls[callIndex]?.[1] as string[] | undefined;
|
|
const specFlagIndex = args?.indexOf('--team-bootstrap-spec') ?? -1;
|
|
const specPath = specFlagIndex >= 0 ? args?.[specFlagIndex + 1] : null;
|
|
if (!specPath) {
|
|
throw new Error('Failed to extract bootstrap spec path from spawn args');
|
|
}
|
|
return JSON.parse(fs.readFileSync(specPath, 'utf8')) as {
|
|
mode?: string;
|
|
team?: { name?: string; cwd?: string };
|
|
lead?: { permissionSeedTools?: string[] };
|
|
members?: Array<Record<string, unknown>>;
|
|
launch?: { bootstrapTimeoutMs?: number; continueOnPartialFailure?: boolean };
|
|
};
|
|
}
|
|
|
|
function readRuntimeSettingsFromLaunchArgs(callIndex = 0): Record<string, unknown> {
|
|
const args = vi.mocked(spawnCli).mock.calls[callIndex]?.[1] as string[] | undefined;
|
|
const settingsFlagIndex = args?.indexOf('--settings') ?? -1;
|
|
const settingsValue = settingsFlagIndex >= 0 ? args?.[settingsFlagIndex + 1] : null;
|
|
if (!settingsValue) {
|
|
throw new Error('Failed to extract runtime settings from spawn args');
|
|
}
|
|
if (settingsValue.trim().startsWith('{')) {
|
|
return JSON.parse(settingsValue) as Record<string, unknown>;
|
|
}
|
|
return JSON.parse(fs.readFileSync(settingsValue, 'utf8')) as Record<string, unknown>;
|
|
}
|
|
|
|
function readRuntimeSettingsPathFromLaunchArgs(callIndex = 0): string {
|
|
const args = vi.mocked(spawnCli).mock.calls[callIndex]?.[1] as string[] | undefined;
|
|
const settingsFlagIndex = args?.indexOf('--settings') ?? -1;
|
|
const settingsValue = settingsFlagIndex >= 0 ? args?.[settingsFlagIndex + 1] : null;
|
|
if (!settingsValue || settingsValue.trim().startsWith('{')) {
|
|
throw new Error('Failed to extract runtime settings path from spawn args');
|
|
}
|
|
return settingsValue;
|
|
}
|
|
|
|
function registerNoopOpenCodeRuntimeAdapter(svc: TeamProvisioningService): void {
|
|
svc.setRuntimeAdapterRegistry(
|
|
new TeamRuntimeAdapterRegistry([
|
|
{
|
|
providerId: 'opencode',
|
|
prepare: vi.fn(async (input: { model?: string }) => ({
|
|
ok: true,
|
|
providerId: 'opencode',
|
|
modelId: input.model ?? null,
|
|
diagnostics: [],
|
|
warnings: [],
|
|
})),
|
|
launch: vi.fn(async () => {
|
|
throw new Error('OpenCode side lane launch should not run in this test');
|
|
}),
|
|
reconcile: vi.fn(async () => ({ members: {}, warnings: [], diagnostics: [] })),
|
|
stop: vi.fn(async () => ({ stopped: true, members: {}, warnings: [], diagnostics: [] })),
|
|
} as any,
|
|
])
|
|
);
|
|
}
|
|
|
|
describe('TeamProvisioningService prompt content (solo mode discipline)', () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
tempClaudeRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-team-prompts-'));
|
|
tempTeamsBase = path.join(tempClaudeRoot, 'teams');
|
|
tempTasksBase = path.join(tempClaudeRoot, 'tasks');
|
|
hoisted.paths.claudeRoot = tempClaudeRoot;
|
|
hoisted.paths.teamsBase = tempTeamsBase;
|
|
hoisted.paths.tasksBase = tempTasksBase;
|
|
setAppDataBasePath(tempClaudeRoot);
|
|
fs.mkdirSync(tempTeamsBase, { recursive: true });
|
|
fs.mkdirSync(tempTasksBase, { recursive: true });
|
|
});
|
|
|
|
afterEach(() => {
|
|
setAppDataBasePath(null);
|
|
// Best-effort cleanup of temp dir (per-test)
|
|
try {
|
|
fs.rmSync(tempClaudeRoot, { recursive: true, force: true });
|
|
} catch {
|
|
// ignore
|
|
}
|
|
});
|
|
|
|
it('createTeam uses deterministic bootstrap spec and safe flags in solo mode', async () => {
|
|
vi.mocked(ClaudeBinaryResolver.resolve).mockResolvedValue('/fake/claude');
|
|
const { child, writeSpy } = createFakeChild();
|
|
vi.mocked(spawnCli).mockReturnValue(child as any);
|
|
|
|
const svc = new TeamProvisioningService();
|
|
(svc as any).buildProvisioningEnv = vi.fn(async () => ({
|
|
env: { ANTHROPIC_API_KEY: 'test' },
|
|
authSource: 'anthropic_api_key',
|
|
}));
|
|
(svc as any).validateAgentTeamsMcpRuntime = vi.fn(async () => {});
|
|
(svc as any).startFilesystemMonitor = vi.fn();
|
|
(svc as any).pathExists = vi.fn(async () => false);
|
|
|
|
const { runId } = await svc.createTeam(
|
|
{
|
|
teamName: 'solo-team',
|
|
cwd: process.cwd(),
|
|
members: [],
|
|
description: 'Solo team for prompt test',
|
|
},
|
|
() => {}
|
|
);
|
|
|
|
expect(writeSpy).not.toHaveBeenCalled();
|
|
const bootstrapSpec = extractBootstrapSpec();
|
|
expect(bootstrapSpec.mode).toBe('create');
|
|
expect(bootstrapSpec.team).toMatchObject({
|
|
name: 'solo-team',
|
|
cwd: process.cwd(),
|
|
});
|
|
expect(bootstrapSpec.members).toEqual([]);
|
|
|
|
const launchArgs = vi.mocked(spawnCli).mock.calls[0]?.[1] as string[];
|
|
expect(launchArgs).toContain('--mcp-config');
|
|
expect(launchArgs).toContain('--team-bootstrap-spec');
|
|
expect(launchArgs).not.toContain('--team-bootstrap-user-prompt-file');
|
|
expect(launchArgs).not.toContain('--strict-mcp-config');
|
|
expect(launchArgs).toContain('--disallowedTools');
|
|
const disallowed = launchArgs[launchArgs.indexOf('--disallowedTools') + 1] ?? '';
|
|
expect(disallowed).not.toContain('Agent');
|
|
expect(disallowed).toContain('mcp__agent-teams__team_launch');
|
|
|
|
await svc.cancelProvisioning(runId);
|
|
});
|
|
|
|
it('launchTeam prompt (solo) uses deterministic refresh-only launch instructions', async () => {
|
|
// Seed config.json so launchTeam can validate team existence.
|
|
const teamName = 'solo-team-launch';
|
|
const teamDir = path.join(tempTeamsBase, teamName);
|
|
fs.mkdirSync(teamDir, { recursive: true });
|
|
fs.writeFileSync(
|
|
path.join(teamDir, 'config.json'),
|
|
JSON.stringify({
|
|
name: teamName,
|
|
description: 'Solo team for prompt test',
|
|
members: [{ name: 'team-lead', agentType: 'team-lead' }],
|
|
}),
|
|
'utf8'
|
|
);
|
|
|
|
vi.mocked(ClaudeBinaryResolver.resolve).mockResolvedValue('/fake/claude');
|
|
const { child, writeSpy } = createFakeChild();
|
|
vi.mocked(spawnCli).mockReturnValue(child as any);
|
|
|
|
const svc = new TeamProvisioningService();
|
|
(svc as any).buildProvisioningEnv = vi.fn(async () => ({
|
|
env: { ANTHROPIC_API_KEY: 'test' },
|
|
authSource: 'anthropic_api_key',
|
|
}));
|
|
(svc as any).normalizeTeamConfigForLaunch = vi.fn(async () => {});
|
|
(svc as any).resolveProviderDefaultModel = vi.fn(async () => 'gpt-5.4');
|
|
(svc as any).updateConfigProjectPath = vi.fn(async () => {});
|
|
(svc as any).restorePrelaunchConfig = vi.fn(async () => {});
|
|
(svc as any).persistLaunchStateSnapshot = vi.fn(async () => {});
|
|
(svc as any).resolveLaunchExpectedMembers = vi.fn(async () => ({
|
|
members: [],
|
|
source: 'config-fallback',
|
|
warning: undefined,
|
|
}));
|
|
(svc as any).validateAgentTeamsMcpRuntime = vi.fn(async () => {});
|
|
(svc as any).pathExists = vi.fn(async () => false);
|
|
(svc as any).startFilesystemMonitor = vi.fn();
|
|
|
|
const { runId } = await svc.launchTeam(
|
|
{
|
|
teamName,
|
|
cwd: process.cwd(),
|
|
clearContext: true,
|
|
} as any,
|
|
() => {}
|
|
);
|
|
|
|
expect(writeSpy).not.toHaveBeenCalled();
|
|
const prompt = extractPromptFromBootstrapFile();
|
|
expect(prompt).toContain('SOLO MODE: This team CURRENTLY has ZERO teammates.');
|
|
expect(prompt).toContain(
|
|
'This launch/bootstrap step has already been completed deterministically by the runtime.'
|
|
);
|
|
expect(prompt).toContain('Do NOT start implementation in this turn.');
|
|
expect(prompt).toContain(
|
|
'Use this turn only to review the current board snapshot and confirm operational readiness.'
|
|
);
|
|
expect(prompt).toContain(
|
|
'Do NOT create, assign, or delegate any new task in this turn. If the board is empty, stay silent and wait for a fresh user instruction.'
|
|
);
|
|
expect(prompt).toContain(
|
|
'review_request already notifies the reviewer, so do NOT send a second manual SendMessage for the same review request'
|
|
);
|
|
expect(prompt).toContain('Review is a state transition on the EXISTING work task.');
|
|
expect(prompt).toContain(
|
|
'The REVIEW column is for the same task #X moving through review. It is NOT a signal to create another task for review.'
|
|
);
|
|
expect(prompt).toContain('Task reference formatting (CRITICAL)');
|
|
expect(prompt).toContain('Do NOT manually write [#abcd1234](task://...) in visible text');
|
|
expect(prompt).toContain('task_create_from_message');
|
|
expect(prompt).toContain(`AGENT_BLOCK_OPEN is exactly: ${AGENT_BLOCK_OPEN}`);
|
|
expect(prompt).toContain(`AGENT_BLOCK_CLOSE is exactly: ${AGENT_BLOCK_CLOSE}`);
|
|
expect(prompt).not.toContain('teamctl.js');
|
|
expect(prompt).not.toContain('.claude/tools');
|
|
|
|
const launchArgs = vi.mocked(spawnCli).mock.calls[0]?.[1] as string[];
|
|
expect(launchArgs).toContain('--mcp-config');
|
|
expect(launchArgs).not.toContain('--strict-mcp-config');
|
|
|
|
await svc.cancelProvisioning(runId);
|
|
});
|
|
|
|
it('createTeam bootstrap spec carries teammate descriptors for deterministic startup', async () => {
|
|
vi.mocked(ClaudeBinaryResolver.resolve).mockResolvedValue('/fake/claude');
|
|
const { child, writeSpy } = createFakeChild();
|
|
vi.mocked(spawnCli).mockReturnValue(child as any);
|
|
|
|
const svc = new TeamProvisioningService();
|
|
(svc as any).buildProvisioningEnv = vi.fn(async () => ({
|
|
env: { ANTHROPIC_API_KEY: 'test' },
|
|
authSource: 'anthropic_api_key',
|
|
}));
|
|
(svc as any).validateAgentTeamsMcpRuntime = vi.fn(async () => {});
|
|
(svc as any).startFilesystemMonitor = vi.fn();
|
|
(svc as any).pathExists = vi.fn(async () => false);
|
|
|
|
const { runId } = await svc.createTeam(
|
|
{
|
|
teamName: 'multi-team',
|
|
cwd: process.cwd(),
|
|
members: [{ name: 'alice', role: 'developer' }],
|
|
description: 'Multi team prompt test',
|
|
},
|
|
() => {}
|
|
);
|
|
|
|
expect(writeSpy).not.toHaveBeenCalled();
|
|
const bootstrapSpec = extractBootstrapSpec();
|
|
expect(bootstrapSpec.mode).toBe('create');
|
|
expect(bootstrapSpec.members).toEqual([
|
|
expect.objectContaining({
|
|
name: 'alice',
|
|
role: 'developer',
|
|
description: 'developer',
|
|
cwd: process.cwd(),
|
|
}),
|
|
]);
|
|
expect(bootstrapSpec.launch).toMatchObject({
|
|
bootstrapTimeoutMs: 120_000,
|
|
continueOnPartialFailure: true,
|
|
});
|
|
|
|
await svc.cancelProvisioning(runId);
|
|
});
|
|
|
|
it('createTeam scales deterministic bootstrap timeout with member count', async () => {
|
|
vi.mocked(ClaudeBinaryResolver.resolve).mockResolvedValue('/fake/claude');
|
|
const { child } = createFakeChild();
|
|
vi.mocked(spawnCli).mockReturnValue(child as any);
|
|
const setTimeoutSpy = vi.spyOn(global, 'setTimeout');
|
|
|
|
const svc = new TeamProvisioningService();
|
|
(svc as any).buildProvisioningEnv = vi.fn(async () => ({
|
|
env: { ANTHROPIC_API_KEY: 'test' },
|
|
authSource: 'anthropic_api_key',
|
|
}));
|
|
(svc as any).validateAgentTeamsMcpRuntime = vi.fn(async () => {});
|
|
(svc as any).startFilesystemMonitor = vi.fn();
|
|
(svc as any).pathExists = vi.fn(async () => false);
|
|
|
|
let runId: string | undefined;
|
|
try {
|
|
const created = await svc.createTeam(
|
|
{
|
|
teamName: 'large-team',
|
|
cwd: process.cwd(),
|
|
members: [
|
|
{ name: 'alice' },
|
|
{ name: 'atlas' },
|
|
{ name: 'bob' },
|
|
{ name: 'jack' },
|
|
{ name: 'tom' },
|
|
],
|
|
},
|
|
() => {}
|
|
);
|
|
runId = created.runId;
|
|
|
|
expect(extractBootstrapSpec().launch).toMatchObject({
|
|
bootstrapTimeoutMs: 375_000,
|
|
continueOnPartialFailure: true,
|
|
});
|
|
|
|
expect(setTimeoutSpy.mock.calls.some((call) => call[1] === 405_000)).toBe(true);
|
|
} finally {
|
|
if (runId) {
|
|
await svc.cancelProvisioning(runId);
|
|
}
|
|
setTimeoutSpy.mockRestore();
|
|
}
|
|
});
|
|
|
|
it('createTeam bootstrap spec includes worktree isolation only for selected teammates', async () => {
|
|
vi.mocked(ClaudeBinaryResolver.resolve).mockResolvedValue('/fake/claude');
|
|
const { child } = createFakeChild();
|
|
vi.mocked(spawnCli).mockReturnValue(child as any);
|
|
|
|
const svc = new TeamProvisioningService();
|
|
(svc as any).buildProvisioningEnv = vi.fn(async () => ({
|
|
env: { ANTHROPIC_API_KEY: 'test' },
|
|
authSource: 'anthropic_api_key',
|
|
}));
|
|
(svc as any).validateAgentTeamsMcpRuntime = vi.fn(async () => {});
|
|
(svc as any).startFilesystemMonitor = vi.fn();
|
|
(svc as any).pathExists = vi.fn(async () => false);
|
|
|
|
const { runId } = await svc.createTeam(
|
|
{
|
|
teamName: 'worktree-mixed-team',
|
|
cwd: process.cwd(),
|
|
members: [
|
|
{ name: 'alice', role: 'developer', isolation: 'worktree' },
|
|
{ name: 'bob', role: 'reviewer' },
|
|
],
|
|
},
|
|
() => {}
|
|
);
|
|
|
|
const bootstrapSpec = extractBootstrapSpec();
|
|
expect(bootstrapSpec.members?.[0]).toEqual(
|
|
expect.objectContaining({ name: 'alice', isolation: 'worktree' })
|
|
);
|
|
expect(bootstrapSpec.members?.[1]).toEqual(expect.objectContaining({ name: 'bob' }));
|
|
expect(bootstrapSpec.members?.[1]).not.toHaveProperty('isolation');
|
|
|
|
await svc.cancelProvisioning(runId);
|
|
});
|
|
|
|
it('forwards codex provider launch overrides into createTeam runtime args', async () => {
|
|
vi.mocked(ClaudeBinaryResolver.resolve).mockResolvedValue('/fake/codex');
|
|
const { child } = createFakeChild();
|
|
vi.mocked(spawnCli).mockReturnValue(child as any);
|
|
|
|
const svc = new TeamProvisioningService();
|
|
(svc as any).buildProvisioningEnv = vi.fn(async () => ({
|
|
env: {},
|
|
authSource: 'codex_runtime',
|
|
providerArgs: ['--settings', '{"codex":{"forced_login_method":"chatgpt"}}'],
|
|
}));
|
|
(svc as any).validateAgentTeamsMcpRuntime = vi.fn(async () => {});
|
|
(svc as any).startFilesystemMonitor = vi.fn();
|
|
(svc as any).pathExists = vi.fn(async () => false);
|
|
|
|
const { runId } = await svc.createTeam(
|
|
{
|
|
teamName: 'codex-team',
|
|
cwd: process.cwd(),
|
|
members: [],
|
|
providerId: 'codex',
|
|
},
|
|
() => {}
|
|
);
|
|
|
|
const launchArgs = vi.mocked(spawnCli).mock.calls[0]?.[1] as string[];
|
|
expect(launchArgs).toEqual(
|
|
expect.arrayContaining(['--settings', '{"codex":{"forced_login_method":"chatgpt"}}'])
|
|
);
|
|
|
|
await svc.cancelProvisioning(runId);
|
|
});
|
|
|
|
it('coalesces codex cross-provider launch overrides into createTeam Anthropic runtime settings', async () => {
|
|
vi.mocked(ClaudeBinaryResolver.resolve).mockResolvedValue('/fake/claude');
|
|
const { child } = createFakeChild();
|
|
vi.mocked(spawnCli).mockReturnValue(child as any);
|
|
|
|
const svc = new TeamProvisioningService();
|
|
registerNoopOpenCodeRuntimeAdapter(svc);
|
|
(svc as any).buildProvisioningEnv = vi.fn(async (providerId: string | undefined) =>
|
|
providerId === 'codex'
|
|
? {
|
|
env: {
|
|
CLAUDE_CODE_CODEX_BACKEND: 'codex-native',
|
|
CLAUDE_CODE_CODEX_FORCED_LOGIN_METHOD: 'chatgpt',
|
|
},
|
|
authSource: 'codex_runtime',
|
|
geminiRuntimeAuth: null,
|
|
providerArgs: ['--settings', '{"codex":{"forced_login_method":"chatgpt"}}'],
|
|
}
|
|
: {
|
|
env: {},
|
|
authSource: 'none',
|
|
geminiRuntimeAuth: null,
|
|
providerArgs: [],
|
|
}
|
|
);
|
|
(svc as any).validateAgentTeamsMcpRuntime = vi.fn(async () => {});
|
|
(svc as any).startFilesystemMonitor = vi.fn();
|
|
(svc as any).pathExists = vi.fn(async () => false);
|
|
|
|
const { runId } = await svc.createTeam(
|
|
{
|
|
teamName: 'anthropic-codex-create-team',
|
|
cwd: process.cwd(),
|
|
members: [
|
|
{ name: 'alice', role: 'developer', providerId: 'codex' },
|
|
{
|
|
name: 'bob',
|
|
role: 'reviewer',
|
|
providerId: 'opencode',
|
|
model: 'minimax-m2.5-free',
|
|
},
|
|
],
|
|
providerId: 'anthropic',
|
|
},
|
|
() => {}
|
|
);
|
|
|
|
const launchArgs = vi.mocked(spawnCli).mock.calls[0]?.[1] as string[];
|
|
expect(launchArgs).not.toContain('{"codex":{"forced_login_method":"chatgpt"}}');
|
|
expect(launchArgs.join(' ')).not.toContain('minimax-m2.5-free');
|
|
expect(extractBootstrapSpec().members).toEqual([
|
|
expect.objectContaining({ name: 'alice', provider: 'codex' }),
|
|
]);
|
|
const settingsPath = readRuntimeSettingsPathFromLaunchArgs();
|
|
const launchEnv = vi.mocked(spawnCli).mock.calls[0]?.[2]?.env as NodeJS.ProcessEnv;
|
|
expect(launchEnv.CLAUDE_TEAM_RUNTIME_SETTINGS_PATH).toBe(settingsPath);
|
|
const settings = readRuntimeSettingsFromLaunchArgs();
|
|
expect((settings.codex as Record<string, unknown>).forced_login_method).toBe('chatgpt');
|
|
|
|
await svc.cancelProvisioning(runId);
|
|
});
|
|
|
|
it('blocks Codex xhigh launch effort until runtime exposes reasoning config passthrough', async () => {
|
|
vi.mocked(ClaudeBinaryResolver.resolve).mockResolvedValue('/fake/codex');
|
|
vi.mocked(spawnCli).mockReset();
|
|
|
|
const svc = new TeamProvisioningService();
|
|
(svc as any).buildProvisioningEnv = vi.fn(async () => ({
|
|
env: {},
|
|
authSource: 'codex_runtime',
|
|
providerArgs: [],
|
|
}));
|
|
(svc as any).validateAgentTeamsMcpRuntime = vi.fn(async () => {});
|
|
(svc as any).startFilesystemMonitor = vi.fn();
|
|
(svc as any).pathExists = vi.fn(async () => false);
|
|
|
|
await expect(
|
|
svc.createTeam(
|
|
{
|
|
teamName: 'codex-xhigh-blocked',
|
|
cwd: process.cwd(),
|
|
members: [],
|
|
providerId: 'codex',
|
|
effort: 'xhigh',
|
|
},
|
|
() => {}
|
|
)
|
|
).rejects.toThrow('does not expose Codex reasoning config passthrough yet');
|
|
|
|
expect(spawnCli).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('blocks future Codex catalog models until runtime declares dynamic launch support', async () => {
|
|
vi.mocked(ClaudeBinaryResolver.resolve).mockResolvedValue('/fake/codex');
|
|
vi.mocked(spawnCli).mockReset();
|
|
|
|
const svc = new TeamProvisioningService();
|
|
(svc as any).buildProvisioningEnv = vi.fn(async () => ({
|
|
env: {},
|
|
authSource: 'codex_runtime',
|
|
providerArgs: [],
|
|
}));
|
|
(svc as any).validateAgentTeamsMcpRuntime = vi.fn(async () => {});
|
|
(svc as any).startFilesystemMonitor = vi.fn();
|
|
(svc as any).pathExists = vi.fn(async () => false);
|
|
|
|
await expect(
|
|
svc.createTeam(
|
|
{
|
|
teamName: 'codex-future-model-blocked',
|
|
cwd: process.cwd(),
|
|
members: [],
|
|
providerId: 'codex',
|
|
model: 'gpt-5.5',
|
|
effort: 'medium',
|
|
},
|
|
() => {}
|
|
)
|
|
).rejects.toThrow('does not declare dynamic Codex model launch support yet');
|
|
|
|
expect(execCli).toHaveBeenCalledWith(
|
|
'/fake/codex',
|
|
['runtime', 'status', '--json', '--provider', 'codex'],
|
|
expect.objectContaining({ cwd: process.cwd() })
|
|
);
|
|
expect(spawnCli).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('allows explicit Codex models when launch model list parsing is degraded', async () => {
|
|
vi.mocked(ClaudeBinaryResolver.resolve).mockResolvedValue('/fake/codex');
|
|
const { child } = createFakeChild();
|
|
vi.mocked(spawnCli).mockReturnValue(child as any);
|
|
|
|
const svc = new TeamProvisioningService();
|
|
(svc as any).buildProvisioningEnv = vi.fn(async () => ({
|
|
env: {},
|
|
authSource: 'codex_runtime',
|
|
providerArgs: [],
|
|
}));
|
|
(svc as any).readRuntimeProviderLaunchFacts = vi.fn(async () => ({
|
|
defaultModel: null,
|
|
modelIds: new Set(),
|
|
modelListParsed: false,
|
|
modelCatalog: null,
|
|
runtimeCapabilities: { modelCatalog: { dynamic: false, source: 'runtime' } },
|
|
providerStatus: null,
|
|
}));
|
|
(svc as any).validateAgentTeamsMcpRuntime = vi.fn(async () => {});
|
|
(svc as any).startFilesystemMonitor = vi.fn();
|
|
(svc as any).pathExists = vi.fn(async () => false);
|
|
|
|
const { runId } = await svc.createTeam(
|
|
{
|
|
teamName: 'codex-future-model-launchable',
|
|
cwd: process.cwd(),
|
|
members: [],
|
|
providerId: 'codex',
|
|
model: 'gpt-5.5',
|
|
effort: 'medium',
|
|
},
|
|
() => {}
|
|
);
|
|
|
|
expect(spawnCli).toHaveBeenCalled();
|
|
await svc.cancelProvisioning(runId);
|
|
});
|
|
|
|
it('restart teammate message keeps the exact teammate identity and avoids duplicate semantics', () => {
|
|
const message = buildRestartMemberSpawnMessage('forge-labs', 'Forge Labs', 'lead', {
|
|
name: 'alice',
|
|
role: 'Reviewer',
|
|
providerId: 'codex',
|
|
model: 'gpt-5.4-mini',
|
|
effort: 'medium',
|
|
});
|
|
|
|
expect(message).toContain('Teammate "alice" with role "Reviewer" was restarted from the UI.');
|
|
expect(message).toContain('team_name="forge-labs", name="alice"');
|
|
expect(message).toContain('provider="codex", model="gpt-5.4-mini", effort="medium"');
|
|
expect(message).toContain(
|
|
'This is a restart of an existing persistent teammate, not a new teammate.'
|
|
);
|
|
expect(message).toContain(
|
|
'If the Agent tool returns duplicate_skipped with reason bootstrap_pending, treat that as a pending restart and wait for teammate check-in.'
|
|
);
|
|
expect(message).toContain(
|
|
'If it returns duplicate_skipped with reason already_running, do not report success - it means the previous runtime still appears active and the restart may not have applied.'
|
|
);
|
|
});
|
|
|
|
it('add and restart teammate prompts include worktree isolation only when selected', () => {
|
|
const addMessage = buildAddMemberSpawnMessage('forge-labs', 'Forge Labs', 'lead', {
|
|
name: 'alice',
|
|
isolation: 'worktree',
|
|
});
|
|
const normalAddMessage = buildAddMemberSpawnMessage('forge-labs', 'Forge Labs', 'lead', {
|
|
name: 'bob',
|
|
});
|
|
const restartMessage = buildRestartMemberSpawnMessage('forge-labs', 'Forge Labs', 'lead', {
|
|
name: 'alice',
|
|
isolation: 'worktree',
|
|
});
|
|
|
|
expect(addMessage).toContain('isolation="worktree"');
|
|
expect(restartMessage).toContain('isolation="worktree"');
|
|
expect(normalAddMessage).not.toContain('isolation="worktree"');
|
|
});
|
|
|
|
it('add and restart teammate prompts can carry strict MCP launch overrides for Agent tool spawns', () => {
|
|
const mcpLaunchConfig = {
|
|
mcpConfigPath: '/tmp/team path/alice-mcp.json',
|
|
mcpSettingSources: 'user,project,local',
|
|
strictMcpConfig: true,
|
|
};
|
|
const addMessage = buildAddMemberSpawnMessage(
|
|
'forge-labs',
|
|
'Forge Labs',
|
|
'lead',
|
|
{
|
|
name: 'alice',
|
|
providerId: 'codex',
|
|
},
|
|
mcpLaunchConfig
|
|
);
|
|
const restartMessage = buildRestartMemberSpawnMessage(
|
|
'forge-labs',
|
|
'Forge Labs',
|
|
'lead',
|
|
{
|
|
name: 'alice',
|
|
providerId: 'codex',
|
|
},
|
|
mcpLaunchConfig
|
|
);
|
|
|
|
expect(addMessage).toContain(
|
|
'mcp_config="/tmp/team path/alice-mcp.json", mcp_setting_sources="user,project,local", strict_mcp_config=true'
|
|
);
|
|
expect(restartMessage).toContain(
|
|
'mcp_config="/tmp/team path/alice-mcp.json", mcp_setting_sources="user,project,local", strict_mcp_config=true'
|
|
);
|
|
});
|
|
|
|
it('createTeam materializes an explicit Codex default model for teammates before bootstrap spawn', async () => {
|
|
vi.mocked(ClaudeBinaryResolver.resolve).mockResolvedValue('/fake/claude');
|
|
const { child } = createFakeChild();
|
|
vi.mocked(spawnCli).mockReturnValue(child as any);
|
|
|
|
const svc = new TeamProvisioningService();
|
|
(svc as any).buildProvisioningEnv = vi.fn(async () => ({
|
|
env: { PATH: '/usr/bin' },
|
|
authSource: 'codex_runtime',
|
|
geminiRuntimeAuth: null,
|
|
}));
|
|
(svc as any).resolveProviderDefaultModel = vi.fn(async () => 'gpt-5.4');
|
|
(svc as any).validateAgentTeamsMcpRuntime = vi.fn(async () => {});
|
|
(svc as any).startFilesystemMonitor = vi.fn();
|
|
(svc as any).pathExists = vi.fn(async () => false);
|
|
|
|
const { runId } = await svc.createTeam(
|
|
{
|
|
teamName: 'codex-default-team',
|
|
cwd: process.cwd(),
|
|
providerId: 'codex',
|
|
members: [{ name: 'alice', role: 'developer', providerId: 'codex' }],
|
|
},
|
|
() => {}
|
|
);
|
|
|
|
const bootstrapSpec = extractBootstrapSpec();
|
|
expect(bootstrapSpec.members).toEqual([
|
|
expect.objectContaining({
|
|
name: 'alice',
|
|
provider: 'codex',
|
|
model: 'gpt-5.4',
|
|
}),
|
|
]);
|
|
|
|
await svc.cancelProvisioning(runId);
|
|
});
|
|
|
|
it('createTeam fails fast when a Codex teammate default model cannot be resolved', async () => {
|
|
vi.mocked(ClaudeBinaryResolver.resolve).mockResolvedValue('/fake/claude');
|
|
vi.mocked(spawnCli).mockReset();
|
|
|
|
const svc = new TeamProvisioningService();
|
|
(svc as any).buildProvisioningEnv = vi.fn(async () => ({
|
|
env: { PATH: '/usr/bin' },
|
|
authSource: 'codex_runtime',
|
|
geminiRuntimeAuth: null,
|
|
}));
|
|
(svc as any).resolveProviderDefaultModel = vi.fn(async () => null);
|
|
(svc as any).validateAgentTeamsMcpRuntime = vi.fn(async () => {});
|
|
(svc as any).startFilesystemMonitor = vi.fn();
|
|
(svc as any).pathExists = vi.fn(async () => false);
|
|
|
|
await expect(
|
|
svc.createTeam(
|
|
{
|
|
teamName: 'codex-default-missing',
|
|
cwd: process.cwd(),
|
|
providerId: 'codex',
|
|
members: [{ name: 'alice', providerId: 'codex' }],
|
|
},
|
|
() => {}
|
|
)
|
|
).rejects.toThrow(
|
|
'Could not resolve the runtime default model for Codex teammates. Select an explicit model and retry.'
|
|
);
|
|
|
|
expect(spawnCli).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('add-member spawn prompt tells teammates to keep review on the same task', () => {
|
|
const prompt = buildAddMemberSpawnMessage('my-team', 'My Team', 'team-lead', {
|
|
name: 'alice',
|
|
role: 'developer',
|
|
});
|
|
|
|
expect(prompt).toContain(
|
|
'Review flow rule: review is a state transition on the SAME work task'
|
|
);
|
|
expect(prompt).toContain('Do NOT create a separate "review task"');
|
|
expect(prompt).toContain('If no reviewer exists, leave #X completed.');
|
|
expect(prompt).toContain(
|
|
'If you are the reviewer for task #X, call review_start on #X first, then review_approve or review_request_changes on #X itself.'
|
|
);
|
|
});
|
|
|
|
it('teammate spawn prompts forbid manual task markdown links in visible messages', () => {
|
|
const addPrompt = buildAddMemberSpawnMessage('my-team', 'My Team', 'team-lead', {
|
|
name: 'alice',
|
|
role: 'developer',
|
|
});
|
|
const restartPrompt = buildRestartMemberSpawnMessage('my-team', 'My Team', 'team-lead', {
|
|
name: 'alice',
|
|
role: 'developer',
|
|
});
|
|
|
|
for (const prompt of [addPrompt, restartPrompt]) {
|
|
expect(prompt).toContain('Task reference formatting (CRITICAL)');
|
|
expect(prompt).toContain('write task refs as plain #<short-id> text');
|
|
expect(prompt).toContain(
|
|
'Never wrap task refs or Markdown task links in backticks/code spans'
|
|
);
|
|
expect(prompt).toContain('Do NOT manually write [#abcd1234](task://...) in visible text');
|
|
expect(prompt).toContain('include structured taskRefs metadata');
|
|
}
|
|
});
|
|
|
|
it('add-member spawn prompt explicitly forbids no-task bootstrap chatter', () => {
|
|
const prompt = buildAddMemberSpawnMessage('my-team', 'My Team', 'team-lead', {
|
|
name: 'alice',
|
|
role: 'developer',
|
|
});
|
|
|
|
expect(prompt).toContain(
|
|
'When you later receive work or reconnect after a restart, use task_briefing as your primary working queue.'
|
|
);
|
|
expect(prompt).toContain(
|
|
'Use task_list only to search/browse inventory rows, not as your working queue.'
|
|
);
|
|
expect(prompt).toContain(
|
|
'Awareness items are watch-only context unless the lead reroutes the task or you become the actionOwner.'
|
|
);
|
|
expect(prompt).toContain(
|
|
'If bootstrap succeeded and you have no task, produce ZERO assistant text for that turn and end it immediately after the successful tool result.'
|
|
);
|
|
expect(prompt).toContain(
|
|
'Do NOT ask the user or the lead to send you a task ID, task description, or "next task" right after bootstrap.'
|
|
);
|
|
expect(prompt).toContain('retry tool search at most once');
|
|
expect(prompt).toContain('Do NOT keep searching for member_briefing');
|
|
});
|
|
|
|
it('launchTeam hydration prompt includes task-comment handling guidance by default', async () => {
|
|
const teamName = 'forward-live-team';
|
|
const teamDir = path.join(tempTeamsBase, teamName);
|
|
fs.mkdirSync(teamDir, { recursive: true });
|
|
fs.writeFileSync(
|
|
path.join(teamDir, 'config.json'),
|
|
JSON.stringify({
|
|
name: teamName,
|
|
description: 'Task comment forwarding live prompt test',
|
|
members: [
|
|
{ name: 'team-lead', agentType: 'team-lead' },
|
|
{ name: 'alice', agentType: 'teammate', role: 'developer' },
|
|
],
|
|
}),
|
|
'utf8'
|
|
);
|
|
|
|
vi.mocked(ClaudeBinaryResolver.resolve).mockResolvedValue('/fake/claude');
|
|
const { child, writeSpy } = createFakeChild();
|
|
vi.mocked(spawnCli).mockReturnValue(child as any);
|
|
|
|
const svc = new TeamProvisioningService();
|
|
(svc as any).buildProvisioningEnv = vi.fn(async () => ({
|
|
env: { ANTHROPIC_API_KEY: 'test' },
|
|
authSource: 'anthropic_api_key',
|
|
}));
|
|
(svc as any).normalizeTeamConfigForLaunch = vi.fn(async () => {});
|
|
(svc as any).resolveProviderDefaultModel = vi.fn(async () => 'gpt-5.4');
|
|
(svc as any).updateConfigProjectPath = vi.fn(async () => {});
|
|
(svc as any).restorePrelaunchConfig = vi.fn(async () => {});
|
|
(svc as any).assertConfigLeadOnlyForLaunch = vi.fn(async () => {});
|
|
(svc as any).persistLaunchStateSnapshot = vi.fn(async () => {});
|
|
(svc as any).resolveLaunchExpectedMembers = vi.fn(async () => ({
|
|
members: [{ name: 'alice', role: 'developer' }],
|
|
source: 'config-fallback',
|
|
warning: undefined,
|
|
}));
|
|
(svc as any).validateAgentTeamsMcpRuntime = vi.fn(async () => {});
|
|
(svc as any).startFilesystemMonitor = vi.fn();
|
|
(svc as any).pathExists = vi.fn(async () => false);
|
|
|
|
const { runId } = await svc.launchTeam(
|
|
{
|
|
teamName,
|
|
cwd: process.cwd(),
|
|
clearContext: true,
|
|
},
|
|
() => {}
|
|
);
|
|
|
|
expect(writeSpy).not.toHaveBeenCalled();
|
|
const prompt = extractPromptFromBootstrapFile();
|
|
expect(prompt).toContain('Teammate task comments are auto-forwarded to you.');
|
|
|
|
await svc.cancelProvisioning(runId);
|
|
});
|
|
|
|
it('launchTeam bootstrap prompt for teammates includes explicit hidden-instruction block rules', async () => {
|
|
const teamName = 'multi-team-launch';
|
|
const teamDir = path.join(tempTeamsBase, teamName);
|
|
fs.mkdirSync(teamDir, { recursive: true });
|
|
fs.writeFileSync(
|
|
path.join(teamDir, 'config.json'),
|
|
JSON.stringify({
|
|
name: teamName,
|
|
description: 'Multi team prompt test',
|
|
members: [
|
|
{ name: 'team-lead', agentType: 'team-lead' },
|
|
{ name: 'alice', agentType: 'teammate', role: 'developer' },
|
|
],
|
|
}),
|
|
'utf8'
|
|
);
|
|
|
|
vi.mocked(ClaudeBinaryResolver.resolve).mockResolvedValue('/fake/claude');
|
|
const { child, writeSpy } = createFakeChild();
|
|
vi.mocked(spawnCli).mockReturnValue(child as any);
|
|
|
|
const svc = new TeamProvisioningService();
|
|
(svc as any).buildProvisioningEnv = vi.fn(async () => ({
|
|
env: { ANTHROPIC_API_KEY: 'test' },
|
|
authSource: 'anthropic_api_key',
|
|
}));
|
|
(svc as any).normalizeTeamConfigForLaunch = vi.fn(async () => {});
|
|
(svc as any).resolveProviderDefaultModel = vi.fn(async () => 'gpt-5.4');
|
|
(svc as any).updateConfigProjectPath = vi.fn(async () => {});
|
|
(svc as any).restorePrelaunchConfig = vi.fn(async () => {});
|
|
(svc as any).assertConfigLeadOnlyForLaunch = vi.fn(async () => {});
|
|
(svc as any).persistLaunchStateSnapshot = vi.fn(async () => {});
|
|
(svc as any).resolveLaunchExpectedMembers = vi.fn(async () => ({
|
|
members: [{ name: 'alice', role: 'developer' }],
|
|
source: 'config-fallback',
|
|
warning: undefined,
|
|
}));
|
|
(svc as any).validateAgentTeamsMcpRuntime = vi.fn(async () => {});
|
|
(svc as any).pathExists = vi.fn(async () => false);
|
|
(svc as any).startFilesystemMonitor = vi.fn();
|
|
|
|
const { runId } = await svc.launchTeam(
|
|
{
|
|
teamName,
|
|
cwd: process.cwd(),
|
|
clearContext: true,
|
|
} as any,
|
|
() => {}
|
|
);
|
|
|
|
expect(writeSpy).not.toHaveBeenCalled();
|
|
const prompt = extractPromptFromBootstrapFile();
|
|
expect(prompt).toContain(
|
|
'This launch/bootstrap step has already been completed deterministically by the runtime.'
|
|
);
|
|
expect(prompt).toContain('Do NOT use Agent to spawn or restore teammates.');
|
|
expect(prompt).toContain(
|
|
'Use this turn only to review the current board snapshot and teammate readiness.'
|
|
);
|
|
expect(prompt).toContain(
|
|
'Do NOT create, assign, or delegate any new task in this turn. If the board is empty, stay silent and wait for a fresh user instruction.'
|
|
);
|
|
expect(prompt).toContain('DELEGATION-FIRST (behavior rule for ALL future lead turns):');
|
|
expect(prompt).toContain(`AGENT_BLOCK_OPEN is exactly: ${AGENT_BLOCK_OPEN}`);
|
|
expect(prompt).toContain(`AGENT_BLOCK_CLOSE is exactly: ${AGENT_BLOCK_CLOSE}`);
|
|
expect(prompt).toContain(
|
|
'Messages to "user" (the human) must NEVER contain agent-only blocks.'
|
|
);
|
|
expect(prompt).toContain('task_create_from_message');
|
|
expect(prompt).toContain('task_set_owner');
|
|
expect(prompt).toContain('cross_team_send');
|
|
expect(prompt).toContain(
|
|
'lead_briefing is the primary lead queue. Decisions about what to act on now come from lead_briefing, not from raw task_list rows.'
|
|
);
|
|
expect(prompt).toContain('Browse/search compact inventory rows only: task_list');
|
|
expect(prompt).toContain(
|
|
`Browse/search compact inventory rows only: task_list { teamName: "${teamName}", owner?: "<member>", status?: "pending|in_progress|completed"`
|
|
);
|
|
expect(prompt).not.toContain(
|
|
`Browse/search compact inventory rows only: task_list { teamName: "${teamName}", owner?: "<member>", status?: "pending|in_progress|completed|deleted"`
|
|
);
|
|
expect(prompt).toContain(
|
|
"task_list is inventory/search/drill-down only. Do NOT treat task_list as the lead's working queue."
|
|
);
|
|
expect(prompt).toContain('review_request already notifies the reviewer');
|
|
expect(prompt).toContain('By default, NEVER create a separate "review task".');
|
|
expect(prompt).toContain('Only move #X into REVIEW when a real reviewer exists for #X.');
|
|
expect(prompt).not.toContain('Only create a separate review reminder/assignment task');
|
|
expect(prompt).toContain(
|
|
'Correct flow: finish implementation on #X -> task_complete #X -> review_request #X -> reviewer runs review_start #X -> reviewer runs review_approve or review_request_changes on #X.'
|
|
);
|
|
await svc.cancelProvisioning(runId);
|
|
});
|
|
|
|
it('launchTeam materializes an explicit Codex default model for launch teammates before bootstrap spawn', async () => {
|
|
const teamName = 'codex-default-launch';
|
|
const teamDir = path.join(tempTeamsBase, teamName);
|
|
fs.mkdirSync(teamDir, { recursive: true });
|
|
fs.writeFileSync(
|
|
path.join(teamDir, 'config.json'),
|
|
JSON.stringify({
|
|
name: teamName,
|
|
members: [
|
|
{ name: 'team-lead', agentType: 'team-lead', providerId: 'codex' },
|
|
{ name: 'alice', agentType: 'teammate', role: 'developer', providerId: 'codex' },
|
|
],
|
|
}),
|
|
'utf8'
|
|
);
|
|
|
|
vi.mocked(ClaudeBinaryResolver.resolve).mockResolvedValue('/fake/claude');
|
|
const { child } = createFakeChild();
|
|
vi.mocked(spawnCli).mockReturnValue(child as any);
|
|
|
|
const svc = new TeamProvisioningService();
|
|
(svc as any).buildProvisioningEnv = vi.fn(async () => ({
|
|
env: { PATH: '/usr/bin' },
|
|
authSource: 'codex_runtime',
|
|
geminiRuntimeAuth: null,
|
|
}));
|
|
(svc as any).resolveProviderDefaultModel = vi.fn(async () => 'gpt-5.4');
|
|
(svc as any).normalizeTeamConfigForLaunch = vi.fn(async () => {});
|
|
(svc as any).resolveProviderDefaultModel = vi.fn(async () => 'gpt-5.4');
|
|
(svc as any).updateConfigProjectPath = vi.fn(async () => {});
|
|
(svc as any).restorePrelaunchConfig = vi.fn(async () => {});
|
|
(svc as any).assertConfigLeadOnlyForLaunch = vi.fn(async () => {});
|
|
(svc as any).persistLaunchStateSnapshot = vi.fn(async () => {});
|
|
(svc as any).validateAgentTeamsMcpRuntime = vi.fn(async () => {});
|
|
(svc as any).pathExists = vi.fn(async () => false);
|
|
(svc as any).startFilesystemMonitor = vi.fn();
|
|
|
|
const { runId } = await svc.launchTeam(
|
|
{
|
|
teamName,
|
|
cwd: process.cwd(),
|
|
providerId: 'codex',
|
|
clearContext: true,
|
|
} as any,
|
|
() => {}
|
|
);
|
|
|
|
const bootstrapSpec = extractBootstrapSpec();
|
|
expect(bootstrapSpec.members).toEqual([
|
|
expect.objectContaining({
|
|
name: 'alice',
|
|
provider: 'codex',
|
|
model: 'gpt-5.4',
|
|
}),
|
|
]);
|
|
|
|
await svc.cancelProvisioning(runId);
|
|
});
|
|
|
|
it('forwards codex provider launch overrides into launchTeam runtime args', async () => {
|
|
const teamName = 'codex-launch-forced-login';
|
|
const teamDir = path.join(tempTeamsBase, teamName);
|
|
fs.mkdirSync(teamDir, { recursive: true });
|
|
fs.writeFileSync(
|
|
path.join(teamDir, 'config.json'),
|
|
JSON.stringify({
|
|
name: teamName,
|
|
members: [
|
|
{ name: 'team-lead', agentType: 'team-lead', providerId: 'codex' },
|
|
{ name: 'alice', agentType: 'teammate', role: 'developer', providerId: 'codex' },
|
|
],
|
|
}),
|
|
'utf8'
|
|
);
|
|
|
|
vi.mocked(ClaudeBinaryResolver.resolve).mockResolvedValue('/fake/codex');
|
|
const { child } = createFakeChild();
|
|
vi.mocked(spawnCli).mockReturnValue(child as any);
|
|
|
|
const svc = new TeamProvisioningService();
|
|
(svc as any).buildProvisioningEnv = vi.fn(async () => ({
|
|
env: {},
|
|
authSource: 'codex_runtime',
|
|
geminiRuntimeAuth: null,
|
|
providerArgs: ['--settings', '{"codex":{"forced_login_method":"chatgpt"}}'],
|
|
}));
|
|
(svc as any).resolveProviderDefaultModel = vi.fn(async () => 'gpt-5.4');
|
|
(svc as any).normalizeTeamConfigForLaunch = vi.fn(async () => {});
|
|
(svc as any).updateConfigProjectPath = vi.fn(async () => {});
|
|
(svc as any).restorePrelaunchConfig = vi.fn(async () => {});
|
|
(svc as any).assertConfigLeadOnlyForLaunch = vi.fn(async () => {});
|
|
(svc as any).persistLaunchStateSnapshot = vi.fn(async () => {});
|
|
(svc as any).resolveLaunchExpectedMembers = vi.fn(async () => ({
|
|
members: [{ name: 'alice', role: 'developer', providerId: 'codex', isolation: 'worktree' }],
|
|
source: 'config-fallback',
|
|
warning: undefined,
|
|
}));
|
|
(svc as any).validateAgentTeamsMcpRuntime = vi.fn(async () => {});
|
|
(svc as any).pathExists = vi.fn(async () => false);
|
|
(svc as any).startFilesystemMonitor = vi.fn();
|
|
|
|
const { runId } = await svc.launchTeam(
|
|
{
|
|
teamName,
|
|
cwd: process.cwd(),
|
|
providerId: 'codex',
|
|
clearContext: true,
|
|
} as any,
|
|
() => {}
|
|
);
|
|
|
|
const launchArgs = vi.mocked(spawnCli).mock.calls[0]?.[1] as string[];
|
|
expect(launchArgs).toEqual(
|
|
expect.arrayContaining(['--settings', '{"codex":{"forced_login_method":"chatgpt"}}'])
|
|
);
|
|
expect(extractBootstrapSpec().members?.[0]).toEqual(
|
|
expect.objectContaining({
|
|
name: 'alice',
|
|
provider: 'codex',
|
|
})
|
|
);
|
|
|
|
await svc.cancelProvisioning(runId);
|
|
});
|
|
|
|
it('coalesces codex cross-provider launch overrides into launchTeam Anthropic runtime settings', async () => {
|
|
const teamName = 'anthropic-codex-launch-team';
|
|
const teamDir = path.join(tempTeamsBase, teamName);
|
|
fs.mkdirSync(teamDir, { recursive: true });
|
|
fs.writeFileSync(
|
|
path.join(teamDir, 'config.json'),
|
|
JSON.stringify({
|
|
name: teamName,
|
|
members: [
|
|
{ name: 'team-lead', agentType: 'team-lead', providerId: 'anthropic' },
|
|
{
|
|
name: 'alice',
|
|
agentType: 'teammate',
|
|
role: 'developer',
|
|
providerId: 'codex',
|
|
model: 'gpt-5.4',
|
|
},
|
|
{
|
|
name: 'bob',
|
|
agentType: 'teammate',
|
|
role: 'reviewer',
|
|
providerId: 'opencode',
|
|
model: 'minimax-m2.5-free',
|
|
},
|
|
],
|
|
}),
|
|
'utf8'
|
|
);
|
|
|
|
vi.mocked(ClaudeBinaryResolver.resolve).mockResolvedValue('/fake/claude');
|
|
const { child } = createFakeChild();
|
|
vi.mocked(spawnCli).mockReturnValue(child as any);
|
|
|
|
const svc = new TeamProvisioningService();
|
|
registerNoopOpenCodeRuntimeAdapter(svc);
|
|
(svc as any).buildProvisioningEnv = vi.fn(async (providerId: string | undefined) =>
|
|
providerId === 'codex'
|
|
? {
|
|
env: {
|
|
CLAUDE_CODE_CODEX_BACKEND: 'codex-native',
|
|
CLAUDE_CODE_CODEX_FORCED_LOGIN_METHOD: 'chatgpt',
|
|
},
|
|
authSource: 'codex_runtime',
|
|
geminiRuntimeAuth: null,
|
|
providerArgs: ['--settings', '{"codex":{"forced_login_method":"chatgpt"}}'],
|
|
}
|
|
: {
|
|
env: {},
|
|
authSource: 'none',
|
|
geminiRuntimeAuth: null,
|
|
providerArgs: [],
|
|
}
|
|
);
|
|
(svc as any).resolveProviderDefaultModel = vi.fn(async (providerId: string | undefined) =>
|
|
providerId === 'codex' ? 'gpt-5.4' : 'opus'
|
|
);
|
|
(svc as any).normalizeTeamConfigForLaunch = vi.fn(async () => {});
|
|
(svc as any).updateConfigProjectPath = vi.fn(async () => {});
|
|
(svc as any).restorePrelaunchConfig = vi.fn(async () => {});
|
|
(svc as any).assertConfigLeadOnlyForLaunch = vi.fn(async () => {});
|
|
(svc as any).persistLaunchStateSnapshot = vi.fn(async () => {});
|
|
(svc as any).resolveLaunchExpectedMembers = vi.fn(async () => ({
|
|
members: [
|
|
{
|
|
name: 'alice',
|
|
role: 'developer',
|
|
providerId: 'codex',
|
|
model: 'gpt-5.4',
|
|
isolation: 'worktree',
|
|
},
|
|
{
|
|
name: 'bob',
|
|
role: 'reviewer',
|
|
providerId: 'opencode',
|
|
model: 'minimax-m2.5-free',
|
|
isolation: 'worktree',
|
|
},
|
|
],
|
|
source: 'config-fallback',
|
|
warning: undefined,
|
|
}));
|
|
(svc as any).validateAgentTeamsMcpRuntime = vi.fn(async () => {});
|
|
(svc as any).pathExists = vi.fn(async () => false);
|
|
(svc as any).startFilesystemMonitor = vi.fn();
|
|
|
|
const { runId } = await svc.launchTeam(
|
|
{
|
|
teamName,
|
|
cwd: process.cwd(),
|
|
providerId: 'anthropic',
|
|
clearContext: true,
|
|
} as any,
|
|
() => {}
|
|
);
|
|
|
|
const launchArgs = vi.mocked(spawnCli).mock.calls[0]?.[1] as string[];
|
|
expect(launchArgs).not.toContain('{"codex":{"forced_login_method":"chatgpt"}}');
|
|
expect(launchArgs.join(' ')).not.toContain('minimax-m2.5-free');
|
|
expect(extractBootstrapSpec().members).toEqual([
|
|
expect.objectContaining({ name: 'alice', provider: 'codex' }),
|
|
]);
|
|
const settingsPath = readRuntimeSettingsPathFromLaunchArgs();
|
|
const launchEnv = vi.mocked(spawnCli).mock.calls[0]?.[2]?.env as NodeJS.ProcessEnv;
|
|
expect(launchEnv.CLAUDE_TEAM_RUNTIME_SETTINGS_PATH).toBe(settingsPath);
|
|
const settings = readRuntimeSettingsFromLaunchArgs();
|
|
expect((settings.codex as Record<string, unknown>).forced_login_method).toBe('chatgpt');
|
|
|
|
await svc.cancelProvisioning(runId);
|
|
});
|
|
});
|