575 lines
24 KiB
TypeScript
575 lines
24 KiB
TypeScript
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
|
|
import {
|
|
accessSync,
|
|
chmodSync,
|
|
constants,
|
|
mkdtempSync,
|
|
mkdirSync,
|
|
writeFileSync,
|
|
rmSync,
|
|
readFileSync,
|
|
renameSync,
|
|
symlinkSync,
|
|
} from 'node:fs';
|
|
import { tmpdir } from 'node:os';
|
|
import { join } from 'node:path';
|
|
import { fileURLToPath } from 'node:url';
|
|
import { FileConfigAdapter } from '../config/file-adapter.js';
|
|
import { composeContract } from './launch.js';
|
|
|
|
/**
|
|
* Composer unit test (R7/R8/R9): asserts the launcher-composed runtime contract
|
|
*
|
|
* - includes the per-tier anchors (CONSTITUTION / AGENTS / USER / runtime),
|
|
* - keeps the CONSTITUTION block byte-equal to the on-disk file (Tier-3
|
|
* byte-equality — the bare-launch fallback read must match what is injected),
|
|
* - merges `*.local.md` operator overlays as deltas-by-value, and omits them
|
|
* entirely when absent (base-only),
|
|
* - selects the correct per-harness RUNTIME.md.
|
|
*
|
|
* `composeContract` takes `mosaicHome` as a param, so each test runs against an
|
|
* isolated fixture home. We also chdir to an empty temp cwd so the cwd-relative
|
|
* mission/PRD blocks contribute nothing (deterministic output).
|
|
*/
|
|
|
|
const CONSTITUTION = '# CONSTITUTION\n\nGATE-1: the non-negotiable law.\n';
|
|
const AGENTS = '# Mosaic Agent Dispatcher\n\nLoad order + guide router.\n';
|
|
const USER = '# operator\n\nName: Test Operator\n';
|
|
const TOOLS = '# tools index\n\n<!-- fleet-comms-contract: 1 -->\n';
|
|
const FRAMEWORK_SOURCE = fileURLToPath(new URL('../../framework', import.meta.url));
|
|
const SOURCE_TOOLS_PATH = join(FRAMEWORK_SOURCE, 'defaults', 'TOOLS.md');
|
|
|
|
function makeHome(): { home: string; root: string } {
|
|
const root = mkdtempSync(join(tmpdir(), 'mosaic-compose-'));
|
|
const home = join(root, 'mosaic-home');
|
|
for (const h of ['claude', 'codex', 'opencode', 'pi']) {
|
|
mkdirSync(join(home, 'runtime', h), { recursive: true });
|
|
writeFileSync(join(home, 'runtime', h, 'RUNTIME.md'), `# ${h} runtime contract\n`);
|
|
}
|
|
mkdirSync(join(home, 'defaults'), { recursive: true });
|
|
mkdirSync(join(home, 'tools', 'tmux'), { recursive: true });
|
|
writeFileSync(join(home, 'defaults', 'TOOLS.md'), TOOLS);
|
|
const helper = join(home, 'tools', 'tmux', 'agent-send.sh');
|
|
writeFileSync(helper, '#!/bin/sh\n');
|
|
chmodSync(helper, 0o755);
|
|
writeFileSync(join(home, 'CONSTITUTION.md'), CONSTITUTION);
|
|
writeFileSync(join(home, 'AGENTS.md'), AGENTS);
|
|
writeFileSync(join(home, 'USER.md'), USER);
|
|
writeFileSync(join(home, 'TOOLS.md'), TOOLS);
|
|
return { home, root };
|
|
}
|
|
|
|
describe('composeContract — overlay composer', () => {
|
|
let fixture: ReturnType<typeof makeHome>;
|
|
let prevCwd: string;
|
|
let cwdDir: string;
|
|
let prevAgentName: string | undefined;
|
|
let prevAgentClass: string | undefined;
|
|
let prevAgentToolPolicy: string | undefined;
|
|
|
|
beforeEach(() => {
|
|
fixture = makeHome();
|
|
prevCwd = process.cwd();
|
|
prevAgentName = process.env['MOSAIC_AGENT_NAME'];
|
|
prevAgentClass = process.env['MOSAIC_AGENT_CLASS'];
|
|
prevAgentToolPolicy = process.env['MOSAIC_AGENT_TOOL_POLICY'];
|
|
delete process.env['MOSAIC_AGENT_NAME'];
|
|
delete process.env['MOSAIC_AGENT_CLASS'];
|
|
delete process.env['MOSAIC_AGENT_TOOL_POLICY'];
|
|
cwdDir = mkdtempSync(join(tmpdir(), 'mosaic-cwd-'));
|
|
process.chdir(cwdDir); // neutralize cwd-relative mission/PRD blocks
|
|
});
|
|
|
|
afterEach(() => {
|
|
process.chdir(prevCwd);
|
|
if (prevAgentName === undefined) delete process.env['MOSAIC_AGENT_NAME'];
|
|
else process.env['MOSAIC_AGENT_NAME'] = prevAgentName;
|
|
if (prevAgentClass === undefined) delete process.env['MOSAIC_AGENT_CLASS'];
|
|
else process.env['MOSAIC_AGENT_CLASS'] = prevAgentClass;
|
|
if (prevAgentToolPolicy === undefined) delete process.env['MOSAIC_AGENT_TOOL_POLICY'];
|
|
else process.env['MOSAIC_AGENT_TOOL_POLICY'] = prevAgentToolPolicy;
|
|
rmSync(fixture.root, { recursive: true, force: true });
|
|
rmSync(cwdDir, { recursive: true, force: true });
|
|
});
|
|
|
|
it('injects the fleet comms cheat-sheet for a spawned fleet agent (situational)', () => {
|
|
// A spawned agent has MOSAIC_AGENT_NAME set + is a member of the roster.
|
|
mkdirSync(join(fixture.home, 'fleet'), { recursive: true });
|
|
writeFileSync(
|
|
join(fixture.home, 'fleet', 'roster.yaml'),
|
|
[
|
|
'version: 1',
|
|
'transport: tmux',
|
|
'tmux:',
|
|
' socket_name: mosaic-fleet',
|
|
'agents:',
|
|
' - name: orchestrator',
|
|
' runtime: claude',
|
|
' class: orchestrator',
|
|
' host: w-jarvis',
|
|
' - name: enhancer',
|
|
' runtime: claude',
|
|
' class: enhancer',
|
|
' host: w-jarvis',
|
|
' - name: coder0-0',
|
|
' runtime: claude',
|
|
' class: implementer',
|
|
' host: 10.1.10.37',
|
|
' ssh: jwoltje@10.1.10.37',
|
|
'',
|
|
].join('\n'),
|
|
);
|
|
const prev = process.env['MOSAIC_AGENT_NAME'];
|
|
try {
|
|
process.env['MOSAIC_AGENT_NAME'] = 'enhancer';
|
|
const outputs = (['claude', 'codex', 'opencode', 'pi'] as const).map((runtime) =>
|
|
composeContract(runtime, fixture.home),
|
|
);
|
|
for (const out of outputs) {
|
|
expect(out).toContain('# Fleet Comms');
|
|
expect(out).toContain('Host: `w-jarvis`');
|
|
expect(out).toContain('Agent/session: `enhancer`');
|
|
expect(out).toContain('tmux socket: `mosaic-fleet`');
|
|
expect(out).toContain(
|
|
`Helper: \`${join(fixture.home, 'tools', 'tmux', 'agent-send.sh')}\``,
|
|
);
|
|
expect(out).toContain('-L mosaic-fleet -s orchestrator -m "…"');
|
|
expect(out).toContain('-L mosaic-fleet -H jwoltje@10.1.10.37 -s coder0-0 -m "…"');
|
|
expect(out).not.toContain('-H jwoltje@10.1.10.37 -s orchestrator');
|
|
}
|
|
const commsSection = (out: string): string => out.slice(out.indexOf('# Fleet Comms'));
|
|
const authoritative = commsSection(outputs[0]!);
|
|
expect(outputs.map(commsSection)).toEqual([
|
|
authoritative,
|
|
authoritative,
|
|
authoritative,
|
|
authoritative,
|
|
]);
|
|
} finally {
|
|
if (prev === undefined) delete process.env['MOSAIC_AGENT_NAME'];
|
|
else process.env['MOSAIC_AGENT_NAME'] = prev;
|
|
}
|
|
});
|
|
|
|
it.each(['claude', 'codex', 'opencode', 'pi'] as const)(
|
|
'derives canonical class, persona, tool policy, and comms from one roster member for %s',
|
|
(runtime) => {
|
|
mkdirSync(join(fixture.home, 'fleet', 'roles'), { recursive: true });
|
|
writeFileSync(
|
|
join(fixture.home, 'fleet', 'roles', 'code.md'),
|
|
'# Code\n\n(`class: code`)\n\nCANONICAL-CODE-MANDATE.\n',
|
|
);
|
|
writeFileSync(
|
|
join(fixture.home, 'fleet', 'roster.yaml'),
|
|
[
|
|
'version: 1',
|
|
'transport: tmux',
|
|
'agents:',
|
|
' - name: exact-coder',
|
|
` runtime: ${runtime}`,
|
|
' class: implementer',
|
|
' tool_policy: operator-interaction',
|
|
'',
|
|
].join('\n'),
|
|
);
|
|
process.env['MOSAIC_AGENT_NAME'] = 'exact-coder';
|
|
process.env['MOSAIC_AGENT_CLASS'] = 'implementer';
|
|
process.env['MOSAIC_AGENT_TOOL_POLICY'] = 'ambient-policy-must-not-win';
|
|
|
|
const out = composeContract(runtime, fixture.home);
|
|
|
|
expect(out).toContain('# Persona Contract (code)');
|
|
expect(out).toContain('CANONICAL-CODE-MANDATE');
|
|
expect(out).toContain('Role/class: `code`');
|
|
expect(out).toContain('# Fleet Tool Policy (operator-interaction)');
|
|
expect(out).not.toContain('ambient-policy-must-not-win');
|
|
expect(out.indexOf('# Persona Contract')).toBeLessThan(out.indexOf('# Fleet Comms'));
|
|
},
|
|
);
|
|
|
|
it.each(['claude', 'codex', 'opencode', 'pi'] as const)(
|
|
'does not inherit ambient tool policy when canonical member omits tool_policy for %s',
|
|
(runtime) => {
|
|
mkdirSync(join(fixture.home, 'fleet', 'roles'), { recursive: true });
|
|
writeFileSync(
|
|
join(fixture.home, 'fleet', 'roles', 'code.md'),
|
|
'# Code\n\n(`class: code`)\n\nCANONICAL-CODE-MANDATE.\n',
|
|
);
|
|
writeFileSync(
|
|
join(fixture.home, 'fleet', 'roster.yaml'),
|
|
[
|
|
'version: 1',
|
|
'transport: tmux',
|
|
'agents:',
|
|
' - name: exact-coder',
|
|
` runtime: ${runtime}`,
|
|
' class: implementer',
|
|
'',
|
|
].join('\n'),
|
|
);
|
|
process.env['MOSAIC_AGENT_NAME'] = 'exact-coder';
|
|
process.env['MOSAIC_AGENT_CLASS'] = 'implementer';
|
|
process.env['MOSAIC_AGENT_TOOL_POLICY'] = 'operator-interaction';
|
|
|
|
const out = composeContract(runtime, fixture.home);
|
|
|
|
expect(out).toContain('# Persona Contract (code)');
|
|
expect(out).toContain('Role/class: `code`');
|
|
expect(out).toContain('# Fleet Comms');
|
|
expect(out).not.toContain('# Fleet Tool Policy (operator-interaction)');
|
|
},
|
|
);
|
|
|
|
it.each(['claude', 'codex', 'opencode', 'pi'] as const)(
|
|
'rejects an ambient class that mismatches the canonical roster member for %s',
|
|
(runtime) => {
|
|
mkdirSync(join(fixture.home, 'fleet'), { recursive: true });
|
|
writeFileSync(
|
|
join(fixture.home, 'fleet', 'roster.yaml'),
|
|
[
|
|
'version: 1',
|
|
'transport: tmux',
|
|
'agents:',
|
|
' - name: exact-coder',
|
|
` runtime: ${runtime}`,
|
|
' class: implementer',
|
|
'',
|
|
].join('\n'),
|
|
);
|
|
process.env['MOSAIC_AGENT_NAME'] = 'exact-coder';
|
|
process.env['MOSAIC_AGENT_CLASS'] = 'reviewer';
|
|
|
|
expect(() => composeContract(runtime, fixture.home)).toThrow(
|
|
/ambient MOSAIC_AGENT_CLASS.*review.*canonical roster.*code/i,
|
|
);
|
|
},
|
|
);
|
|
|
|
it('composes solo role mandate and boundaries before explicit no-peer authority', () => {
|
|
mkdirSync(join(fixture.home, 'fleet', 'roles'), { recursive: true });
|
|
writeFileSync(
|
|
join(fixture.home, 'fleet', 'roles', 'orchestrator.md'),
|
|
'# Orchestrator\n\n## Mandate\n\nCoordinate exact work.\n\n## Boundaries\n\nDo not infer authority.\n',
|
|
);
|
|
writeFileSync(
|
|
join(fixture.home, 'fleet', 'roster.yaml'),
|
|
[
|
|
'version: 1',
|
|
'transport: tmux',
|
|
'agents:',
|
|
' - name: solo',
|
|
' runtime: claude',
|
|
' class: orchestrator',
|
|
'',
|
|
].join('\n'),
|
|
);
|
|
process.env['MOSAIC_AGENT_NAME'] = 'solo';
|
|
process.env['MOSAIC_AGENT_CLASS'] = 'orchestrator';
|
|
|
|
const out = composeContract('claude', fixture.home);
|
|
|
|
expect(out).toContain('## Mandate');
|
|
expect(out).toContain('## Boundaries');
|
|
expect(out).toContain('Role/class: `orchestrator`');
|
|
expect(out).toContain('## Solo authority boundaries');
|
|
expect(out.indexOf('## Mandate')).toBeLessThan(out.indexOf('# Fleet Comms'));
|
|
expect(out.indexOf('## Boundaries')).toBeLessThan(out.indexOf('# Fleet Comms'));
|
|
expect(out).toContain('no peer, orchestrator, or remote communication authority');
|
|
});
|
|
|
|
it('proves real source TOOLS.md through fresh install, executable helper, and final composition', async () => {
|
|
const installRoot = mkdtempSync(join(tmpdir(), 'mosaic-real-contract-'));
|
|
const installedHome = join(installRoot, 'mosaic-home');
|
|
mkdirSync(installedHome, { recursive: true });
|
|
const previous = process.env['MOSAIC_AGENT_NAME'];
|
|
|
|
try {
|
|
const adapter = new FileConfigAdapter(installedHome, FRAMEWORK_SOURCE);
|
|
await adapter.syncFramework('fresh');
|
|
|
|
const sourceTools = readFileSync(SOURCE_TOOLS_PATH, 'utf8');
|
|
const installedToolsPath = join(installedHome, 'TOOLS.md');
|
|
expect(readFileSync(installedToolsPath, 'utf8')).toBe(sourceTools);
|
|
expect(sourceTools).toContain('fleet-comms-contract: 1');
|
|
expect(sourceTools).not.toMatch(
|
|
/<(?:user@host|src_host|src_session|dst_host|dst_session|target-session)>/,
|
|
);
|
|
|
|
const helper = join(installedHome, 'tools', 'tmux', 'agent-send.sh');
|
|
expect(() => accessSync(helper, constants.X_OK)).not.toThrow();
|
|
|
|
mkdirSync(join(installedHome, 'fleet'), { recursive: true });
|
|
writeFileSync(
|
|
join(installedHome, 'fleet', 'roster.yaml'),
|
|
[
|
|
'version: 1',
|
|
'transport: tmux',
|
|
'tmux:',
|
|
' socket_name: exact-socket',
|
|
'agents:',
|
|
' - name: exact-self',
|
|
' runtime: pi',
|
|
' class: orchestrator',
|
|
' host: local-host',
|
|
' - name: exact-peer',
|
|
' runtime: claude',
|
|
' class: implementer',
|
|
' host: local-host',
|
|
'',
|
|
].join('\n'),
|
|
);
|
|
process.env['MOSAIC_AGENT_NAME'] = 'exact-self';
|
|
|
|
const composed = composeContract('pi', installedHome);
|
|
expect(composed).toContain(sourceTools);
|
|
expect(composed).toContain(`Helper: \`${helper}\``);
|
|
expect(composed).toContain(`${helper} -L exact-socket -s exact-peer -m "…"`);
|
|
expect(composed).not.toContain('# Fleet Comms Installation Status');
|
|
} finally {
|
|
if (previous === undefined) delete process.env['MOSAIC_AGENT_NAME'];
|
|
else process.env['MOSAIC_AGENT_NAME'] = previous;
|
|
rmSync(installRoot, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it.each(['claude', 'codex', 'opencode', 'pi'] as const)(
|
|
'never injects installed TOOLS.md through a target symlink for %s',
|
|
(runtime) => {
|
|
const toolsPath = join(fixture.home, 'TOOLS.md');
|
|
const external = join(fixture.root, 'attacker-tools.md');
|
|
writeFileSync(external, 'UNSAFE-TARGET-SYMLINK-CONTENT\n');
|
|
rmSync(toolsPath);
|
|
symlinkSync(external, toolsPath);
|
|
|
|
const out = composeContract(runtime, fixture.home);
|
|
|
|
expect(out).not.toContain('UNSAFE-TARGET-SYMLINK-CONTENT');
|
|
expect(out).toContain('# Fleet Comms Installation Status');
|
|
expect(out).toContain('unavailable');
|
|
expect(readFileSync(external, 'utf8')).toBe('UNSAFE-TARGET-SYMLINK-CONTENT\n');
|
|
},
|
|
);
|
|
|
|
it.each(['claude', 'codex', 'opencode', 'pi'] as const)(
|
|
'never injects installed TOOLS.md through an ancestor symlink for %s',
|
|
(runtime) => {
|
|
const realHome = join(fixture.root, 'real-mosaic-home');
|
|
renameSync(fixture.home, realHome);
|
|
symlinkSync(realHome, fixture.home, 'dir');
|
|
writeFileSync(join(realHome, 'TOOLS.md'), 'UNSAFE-ANCESTOR-SYMLINK-CONTENT\n');
|
|
|
|
const out = composeContract(runtime, fixture.home);
|
|
|
|
expect(out).not.toContain('UNSAFE-ANCESTOR-SYMLINK-CONTENT');
|
|
expect(out).toContain('# Fleet Comms Installation Status');
|
|
expect(out).toContain('unavailable');
|
|
expect(readFileSync(join(realHome, 'TOOLS.md'), 'utf8')).toBe(
|
|
'UNSAFE-ANCESTOR-SYMLINK-CONTENT\n',
|
|
);
|
|
},
|
|
);
|
|
|
|
it('reports stale preserved TOOLS.md without rewriting it', () => {
|
|
const toolsPath = join(fixture.home, 'TOOLS.md');
|
|
const stale = '# user-customized tools without fleet contract marker\n';
|
|
writeFileSync(toolsPath, stale);
|
|
|
|
const out = composeContract('pi', fixture.home);
|
|
|
|
expect(out).toContain('# Fleet Comms Installation Status');
|
|
expect(out).toContain('does not byte-match');
|
|
expect(out).toContain('active context was not rewritten');
|
|
expect(readFileSync(toolsPath, 'utf8')).toBe(stale);
|
|
});
|
|
|
|
it('does NOT inject fleet comms when MOSAIC_AGENT_NAME is unset (non-fleet launch)', () => {
|
|
const prev = process.env['MOSAIC_AGENT_NAME'];
|
|
try {
|
|
delete process.env['MOSAIC_AGENT_NAME'];
|
|
expect(composeContract('claude', fixture.home)).not.toContain('# Fleet Comms');
|
|
} finally {
|
|
if (prev !== undefined) process.env['MOSAIC_AGENT_NAME'] = prev;
|
|
}
|
|
});
|
|
|
|
it('fails closed when an explicitly requested fleet identity is unknown', () => {
|
|
mkdirSync(join(fixture.home, 'fleet'), { recursive: true });
|
|
writeFileSync(
|
|
join(fixture.home, 'fleet', 'roster.yaml'),
|
|
['version: 1', 'transport: tmux', 'agents:', ' - name: exact-agent', ' runtime: pi'].join(
|
|
'\n',
|
|
),
|
|
);
|
|
const previous = process.env['MOSAIC_AGENT_NAME'];
|
|
try {
|
|
process.env['MOSAIC_AGENT_NAME'] = 'invented-agent';
|
|
expect(() => composeContract('pi', fixture.home)).toThrow(/known exact names: exact-agent/i);
|
|
} finally {
|
|
if (previous === undefined) delete process.env['MOSAIC_AGENT_NAME'];
|
|
else process.env['MOSAIC_AGENT_NAME'] = previous;
|
|
}
|
|
});
|
|
|
|
it('includes the per-tier anchors and the selected harness runtime', () => {
|
|
const out = composeContract('claude', fixture.home);
|
|
expect(out).toContain('GATE-1: the non-negotiable law.'); // L0
|
|
expect(out).toContain('Mosaic Agent Dispatcher'); // AGENTS
|
|
expect(out).toContain('# User Profile'); // USER header
|
|
expect(out).toContain('Name: Test Operator'); // USER body
|
|
expect(out).toContain('# Runtime-Specific Contract');
|
|
expect(out).toContain('# claude runtime contract');
|
|
});
|
|
|
|
it('keeps the CONSTITUTION block byte-equal to the on-disk file (Tier-3)', () => {
|
|
const out = composeContract('pi', fixture.home);
|
|
const onDisk = readFileSync(join(fixture.home, 'CONSTITUTION.md'), 'utf-8');
|
|
// The injected L0 must be a byte-equal substring of the composed blob, so a
|
|
// bare-launch fallback read of CONSTITUTION.md matches what was injected.
|
|
expect(out.includes(onDisk)).toBe(true);
|
|
});
|
|
|
|
it('is base-only when no *.local overlays exist', () => {
|
|
const out = composeContract('claude', fixture.home);
|
|
expect(out).not.toContain('# Operator Overlays');
|
|
expect(out).not.toContain('Operator Overlay (USER.local.md)');
|
|
expect(out).not.toContain('Persona Overlay');
|
|
expect(out).not.toContain('Standards Overlay');
|
|
});
|
|
|
|
it('merges USER.local.md directly under the operator profile', () => {
|
|
writeFileSync(join(fixture.home, 'USER.local.md'), 'Prefer terse status updates.\n');
|
|
const out = composeContract('claude', fixture.home);
|
|
expect(out).toContain('## Operator Overlay (USER.local.md)');
|
|
expect(out).toContain('Prefer terse status updates.');
|
|
// Overlay appears AFTER its base profile.
|
|
expect(out.indexOf('# User Profile')).toBeLessThan(
|
|
out.indexOf('## Operator Overlay (USER.local.md)'),
|
|
);
|
|
});
|
|
|
|
it('merges SOUL.local.md + STANDARDS.local.md as deltas in the Operator Overlays block', () => {
|
|
writeFileSync(join(fixture.home, 'SOUL.local.md'), 'Tone: dry and direct.\n');
|
|
writeFileSync(join(fixture.home, 'STANDARDS.local.md'), 'Require 90% coverage on auth code.\n');
|
|
const out = composeContract('claude', fixture.home);
|
|
expect(out).toContain('# Operator Overlays');
|
|
expect(out).toContain('## Persona Overlay (SOUL.local.md)');
|
|
expect(out).toContain('Tone: dry and direct.');
|
|
expect(out).toContain('## Standards Overlay (STANDARDS.local.md)');
|
|
expect(out).toContain('Require 90% coverage on auth code.');
|
|
});
|
|
|
|
it('ignores whitespace-only *.local overlays (no empty overlay section)', () => {
|
|
writeFileSync(join(fixture.home, 'SOUL.local.md'), ' \n\n');
|
|
const out = composeContract('claude', fixture.home);
|
|
expect(out).not.toContain('# Operator Overlays');
|
|
});
|
|
|
|
it('selects a different RUNTIME.md per harness', () => {
|
|
expect(composeContract('codex', fixture.home)).toContain('# codex runtime contract');
|
|
expect(composeContract('pi', fixture.home)).toContain('# pi runtime contract');
|
|
expect(composeContract('codex', fixture.home)).not.toContain('# pi runtime contract');
|
|
});
|
|
|
|
it('injects the configured operator-interaction tool policy into the runtime contract', () => {
|
|
const previous = process.env['MOSAIC_AGENT_TOOL_POLICY'];
|
|
try {
|
|
process.env['MOSAIC_AGENT_TOOL_POLICY'] = 'operator-interaction';
|
|
const out = composeContract('pi', fixture.home);
|
|
expect(out).toContain('# Fleet Tool Policy (operator-interaction)');
|
|
expect(out).toContain('Denied by default: coding/general orchestration claims');
|
|
} finally {
|
|
if (previous === undefined) delete process.env['MOSAIC_AGENT_TOOL_POLICY'];
|
|
else process.env['MOSAIC_AGENT_TOOL_POLICY'] = previous;
|
|
}
|
|
});
|
|
|
|
// ── Persona contract injection (A3b) ──────────────────────────────────────
|
|
// composeContract reads MOSAIC_AGENT_CLASS and injects the resolved persona
|
|
// (override-aware). Save/restore the env so these tests don't leak state.
|
|
describe('persona contract (A3b)', () => {
|
|
let prevClass: string | undefined;
|
|
|
|
beforeEach(() => {
|
|
prevClass = process.env['MOSAIC_AGENT_CLASS'];
|
|
});
|
|
|
|
afterEach(() => {
|
|
if (prevClass === undefined) delete process.env['MOSAIC_AGENT_CLASS'];
|
|
else process.env['MOSAIC_AGENT_CLASS'] = prevClass;
|
|
});
|
|
|
|
const seedBaseline = (klass: string, body: string): void => {
|
|
mkdirSync(join(fixture.home, 'fleet', 'roles'), { recursive: true });
|
|
writeFileSync(join(fixture.home, 'fleet', 'roles', `${klass}.md`), body);
|
|
};
|
|
const seedOverride = (klass: string, body: string): void => {
|
|
mkdirSync(join(fixture.home, 'fleet', 'roles.local'), { recursive: true });
|
|
writeFileSync(join(fixture.home, 'fleet', 'roles.local', `${klass}.md`), body);
|
|
};
|
|
|
|
it('injects the baseline persona when MOSAIC_AGENT_CLASS is set and a role file exists', () => {
|
|
seedBaseline('coder', '# Coder\n\n(`class: coder`)\n\nBASELINE-MANDATE: ship the lane.\n');
|
|
process.env['MOSAIC_AGENT_CLASS'] = 'coder';
|
|
const out = composeContract('claude', fixture.home);
|
|
expect(out).toContain('# Persona Contract (coder)');
|
|
expect(out).toContain('BASELINE-MANDATE');
|
|
});
|
|
|
|
it('OVERRIDE WINS at launch: roles.local persona is injected over baseline (AC-NS-7)', () => {
|
|
seedBaseline('coder', '# Coder\n\n(`class: coder`)\n\nBASELINE-MANDATE.\n');
|
|
seedOverride('coder', '# Coder (override)\n\n(`class: coder`)\n\nOVERRIDE-MANDATE.\n');
|
|
process.env['MOSAIC_AGENT_CLASS'] = 'coder';
|
|
const out = composeContract('claude', fixture.home);
|
|
expect(out).toContain('# Persona Contract (coder)');
|
|
expect(out).toContain('OVERRIDE-MANDATE');
|
|
expect(out).not.toContain('BASELINE-MANDATE');
|
|
});
|
|
|
|
it('does NOT inject a persona when MOSAIC_AGENT_CLASS is unset', () => {
|
|
seedBaseline('coder', '# Coder\n\n(`class: coder`)\n\nBASELINE-MANDATE.\n');
|
|
delete process.env['MOSAIC_AGENT_CLASS'];
|
|
const out = composeContract('claude', fixture.home);
|
|
expect(out).not.toContain('# Persona Contract');
|
|
});
|
|
|
|
it('does NOT inject (no throw) when MOSAIC_AGENT_CLASS names an unknown class', () => {
|
|
seedBaseline('coder', '# Coder\n\n(`class: coder`)\n\nBASELINE-MANDATE.\n');
|
|
process.env['MOSAIC_AGENT_CLASS'] = 'nonexistent';
|
|
expect(() => composeContract('claude', fixture.home)).not.toThrow();
|
|
expect(composeContract('claude', fixture.home)).not.toContain('# Persona Contract');
|
|
});
|
|
|
|
it('places the persona contract BEFORE the fleet comms block (identity, then peers)', () => {
|
|
seedBaseline('enhancer', '# Enhancer\n\n(`class: enhancer`)\n\nIMPROVE.\n');
|
|
mkdirSync(join(fixture.home, 'fleet'), { recursive: true });
|
|
writeFileSync(
|
|
join(fixture.home, 'fleet', 'roster.yaml'),
|
|
[
|
|
'version: 1',
|
|
'transport: tmux',
|
|
'agents:',
|
|
' - name: orchestrator',
|
|
' runtime: claude',
|
|
' class: orchestrator',
|
|
' - name: enhancer',
|
|
' runtime: claude',
|
|
' class: enhancer',
|
|
'',
|
|
].join('\n'),
|
|
);
|
|
const prevName = process.env['MOSAIC_AGENT_NAME'];
|
|
try {
|
|
process.env['MOSAIC_AGENT_CLASS'] = 'enhancer';
|
|
process.env['MOSAIC_AGENT_NAME'] = 'enhancer';
|
|
const out = composeContract('claude', fixture.home);
|
|
expect(out).toContain('# Persona Contract (enhancer)');
|
|
expect(out).toContain('# Fleet Comms');
|
|
expect(out.indexOf('# Persona Contract')).toBeLessThan(out.indexOf('# Fleet Comms'));
|
|
} finally {
|
|
if (prevName === undefined) delete process.env['MOSAIC_AGENT_NAME'];
|
|
else process.env['MOSAIC_AGENT_NAME'] = prevName;
|
|
}
|
|
});
|
|
});
|
|
});
|