606 lines
23 KiB
TypeScript
606 lines
23 KiB
TypeScript
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';
|
|
|
|
import { AGENT_BLOCK_CLOSE, AGENT_BLOCK_OPEN } from '@shared/constants/agentBlocks';
|
|
|
|
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', () => ({
|
|
spawnCli: vi.fn(),
|
|
killProcessTree: vi.fn(),
|
|
}));
|
|
|
|
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 {
|
|
buildAddMemberSpawnMessage,
|
|
buildRestartMemberSpawnMessage,
|
|
TeamProvisioningService,
|
|
} from '@main/services/team/TeamProvisioningService';
|
|
import { ClaudeBinaryResolver } from '@main/services/team/ClaudeBinaryResolver';
|
|
import { 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>>;
|
|
} {
|
|
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>>;
|
|
};
|
|
}
|
|
|
|
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 reconnect 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).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 reconnect/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 refresh context, review the current board snapshot, and confirm you are ready.');
|
|
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_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(),
|
|
}),
|
|
]);
|
|
|
|
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('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('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(
|
|
'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.'
|
|
);
|
|
});
|
|
|
|
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).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 reconnect 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).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 reconnect/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 refresh context and review the current board snapshot.');
|
|
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 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(
|
|
'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).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' }],
|
|
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 bootstrapSpec = extractBootstrapSpec();
|
|
expect(bootstrapSpec.members).toEqual([
|
|
expect.objectContaining({
|
|
name: 'alice',
|
|
provider: 'codex',
|
|
model: 'gpt-5.4',
|
|
}),
|
|
]);
|
|
|
|
await svc.cancelProvisioning(runId);
|
|
});
|
|
});
|