refactor: hard-fork GSD -> MSD (Make Software Done)

Mechanical rename produced by scripts/msd-rename.cjs: gsd/Gsd/GSD -> msd/Msd/MSD
across contents and paths, upstream package/repo coordinates -> @golem15/msd-core
and golem15com/msd-core. Deep links into upstream history, sibling upstream
packages, the GSD-2 import feature, CHANGELOG.md and .changeset/ are kept as-is.

Hand edits on top: MSD block-letter banner and logos, LICENSE copyright line,
package/plugin identity, regenerated lockfile, install-tree fixtures, derived
registries and benchmark baseline; migration checksum baseline re-locked
(MSD keeps its own install state, so no install had applied the old sums);
sort-order and regex-escaped expectations in tests adjusted.
This commit is contained in:
Jakub Zych
2026-10-06 01:47:40 +02:00
parent fe069b2a56
commit a9a7a328e6
2763 changed files with 78465 additions and 78434 deletions

View File

@@ -10,7 +10,7 @@
* 1. Pure-function tests over the typed IR (extractMarkers,
* parseAgentContracts, contractViolations, parseConsumedByCell,
* readTagViolations, unmatchedConsumerTokens) — one row per input
* class in .gsd/phase/feat-3565-contract-drift-registry/50-test-matrix.md.
* class in .msd/phase/feat-3565-contract-drift-registry/50-test-matrix.md.
* 2. A seeded fast-check property: for any interleaving of fenced and
* unfenced blocks, every extracted marker's inFence matches the
* block's declared fenced-ness (fence tracking is the load-bearing
@@ -180,10 +180,10 @@ describe('contract-drift: parseAgentContracts', () => {
'',
'| Agent | Role | Completion Markers | Consumed by | Kind |',
'|-------|------|--------------------|--------------|------|',
'| gsd-a | First | `## ALPHA COMPLETE` | `gsd-core/workflows/w.md` | sentinel-match |',
'| gsd-b | Second | `## BETA COMPLETE`, `## BETA BLOCKED` | prose only | sentinel-match |',
'| gsd-c | Third | `## GAMMA DRAFT` (unconsumed: user draft, approved in chat) | `gsd-core/workflows/w.md` | sentinel-match |',
'| gsd-d | Fourth | No marker (writes a file) | `gsd-core/workflows/w.md` | artifact+query |',
'| msd-a | First | `## ALPHA COMPLETE` | `msd-core/workflows/w.md` | sentinel-match |',
'| msd-b | Second | `## BETA COMPLETE`, `## BETA BLOCKED` | prose only | sentinel-match |',
'| msd-c | Third | `## GAMMA DRAFT` (unconsumed: user draft, approved in chat) | `msd-core/workflows/w.md` | sentinel-match |',
'| msd-d | Fourth | No marker (writes a file) | `msd-core/workflows/w.md` | artifact+query |',
'',
].join('\n');
@@ -193,7 +193,7 @@ describe('contract-drift: parseAgentContracts', () => {
assert.equal(rows.length, 4);
assert.deepEqual(rows[0].completion_markers, ['ALPHA COMPLETE']);
assert.equal(rows[0].kind, 'sentinel-match');
assert.equal(rows[0].agent, 'gsd-a');
assert.equal(rows[0].agent, 'msd-a');
assert.deepEqual(rows[1].completion_markers, ['BETA COMPLETE', 'BETA BLOCKED']);
});
@@ -209,7 +209,7 @@ describe('contract-drift: parseAgentContracts', () => {
'',
'| Agent | Completion Markers |',
'|-------|--------------------|',
'| gsd-x | `## X DRAFT` (unconsumed: draft display, approved interactively) |',
'| msd-x | `## X DRAFT` (unconsumed: draft display, approved interactively) |',
].join('\n');
const { rows } = parseAgentContracts(md);
assert.deepEqual(rows[0].unconsumed_markers, ['X DRAFT']);
@@ -222,7 +222,7 @@ describe('contract-drift: parseAgentContracts', () => {
'',
'| Agent | Completion Markers |',
'|-------|--------------------|',
'| gsd-good | `## OK COMPLETE` |',
'| msd-good | `## OK COMPLETE` |',
'| broken row missing cells |',
'| | `## NO AGENT` |',
].join('\n');
@@ -257,48 +257,48 @@ describe('contract-drift: contractViolations', () => {
test('sentinel-match with a workflow consumer containing the token is satisfied', () => {
const vs = run({
registry: [row('gsd-a', ['ALPHA COMPLETE'], 'sentinel-match')],
producers: new Map([['gsd-a', ['ALPHA COMPLETE']]]),
consumers: new Map([['gsd-core/workflows/w.md', 'match `## ALPHA COMPLETE` here']]),
registry: [row('msd-a', ['ALPHA COMPLETE'], 'sentinel-match')],
producers: new Map([['msd-a', ['ALPHA COMPLETE']]]),
consumers: new Map([['msd-core/workflows/w.md', 'match `## ALPHA COMPLETE` here']]),
});
assert.deepEqual(vs, []);
});
test('sentinel-match with a command consumer is satisfied', () => {
const vs = run({
registry: [row('gsd-a', ['ALPHA COMPLETE'], 'sentinel-match')],
producers: new Map([['gsd-a', ['ALPHA COMPLETE']]]),
consumers: new Map([['commands/gsd/x.md', 'dispatch on `## ALPHA COMPLETE`']]),
registry: [row('msd-a', ['ALPHA COMPLETE'], 'sentinel-match')],
producers: new Map([['msd-a', ['ALPHA COMPLETE']]]),
consumers: new Map([['commands/msd/x.md', 'dispatch on `## ALPHA COMPLETE`']]),
});
assert.deepEqual(vs, []);
});
test('sentinel-match with another AGENT as consumer is satisfied (the gsd-debugger shape)', () => {
test('sentinel-match with another AGENT as consumer is satisfied (the msd-debugger shape)', () => {
const vs = run({
registry: [row('gsd-a', ['ALPHA COMPLETE'], 'sentinel-match')],
producers: new Map([['gsd-a', ['ALPHA COMPLETE']]]),
consumers: new Map([['agents/gsd-b.md', 'when the agent returns `## ALPHA COMPLETE`']]),
registry: [row('msd-a', ['ALPHA COMPLETE'], 'sentinel-match')],
producers: new Map([['msd-a', ['ALPHA COMPLETE']]]),
consumers: new Map([['agents/msd-b.md', 'when the agent returns `## ALPHA COMPLETE`']]),
});
assert.deepEqual(vs, []);
});
test('sentinel-match with no consumer is a no_consumer violation naming producer and token', () => {
const vs = run({
registry: [row('gsd-a', ['ALPHA COMPLETE'], 'sentinel-match')],
producers: new Map([['gsd-a', ['ALPHA COMPLETE']]]),
consumers: new Map([['gsd-core/workflows/w.md', 'unrelated text']]),
registry: [row('msd-a', ['ALPHA COMPLETE'], 'sentinel-match')],
producers: new Map([['msd-a', ['ALPHA COMPLETE']]]),
consumers: new Map([['msd-core/workflows/w.md', 'unrelated text']]),
});
assert.equal(vs.length, 1);
assert.equal(vs[0].kind, 'no_consumer');
assert.equal(vs[0].agent, 'gsd-a');
assert.equal(vs[0].agent, 'msd-a');
assert.equal(vs[0].marker, 'ALPHA COMPLETE');
});
test('an agent never satisfies its own marker', () => {
const vs = run({
registry: [row('gsd-a', ['ALPHA COMPLETE'], 'sentinel-match')],
producers: new Map([['gsd-a', ['ALPHA COMPLETE']]]),
consumers: new Map([['agents/gsd-a.md', 'I emit `## ALPHA COMPLETE` myself']]),
registry: [row('msd-a', ['ALPHA COMPLETE'], 'sentinel-match')],
producers: new Map([['msd-a', ['ALPHA COMPLETE']]]),
consumers: new Map([['agents/msd-a.md', 'I emit `## ALPHA COMPLETE` myself']]),
});
assert.equal(vs.length, 1);
assert.equal(vs[0].kind, 'no_consumer');
@@ -306,17 +306,17 @@ describe('contract-drift: contractViolations', () => {
test('artifact+query with no marker emitted is satisfied', () => {
const vs = run({
registry: [row('gsd-d', [], 'artifact+query')],
producers: new Map([['gsd-d', []]]),
registry: [row('msd-d', [], 'artifact+query')],
producers: new Map([['msd-d', []]]),
});
assert.deepEqual(vs, []);
});
test('artifact+query that still emits a marker is a vestigial_marker violation', () => {
const vs = run({
registry: [row('gsd-d', [], 'artifact+query')],
producers: new Map([['gsd-d', ['VESTIGIAL COMPLETE']]]),
candidates: new Map([['gsd-d', ['VESTIGIAL COMPLETE']]]),
registry: [row('msd-d', [], 'artifact+query')],
producers: new Map([['msd-d', ['VESTIGIAL COMPLETE']]]),
candidates: new Map([['msd-d', ['VESTIGIAL COMPLETE']]]),
});
assert.equal(vs.length, 1);
assert.equal(vs[0].kind, 'vestigial_marker');
@@ -325,34 +325,34 @@ describe('contract-drift: contractViolations', () => {
test('an (unconsumed:) annotation on an artifact+query row exempts vestigial_marker (Marker Rule 2 recorded decision)', () => {
const vs = run({
registry: [row('gsd-v', [], 'artifact+query', { unconsumed_markers: ['Verification Complete'] })],
producers: new Map([['gsd-v', ['Verification Complete']]]),
registry: [row('msd-v', [], 'artifact+query', { unconsumed_markers: ['Verification Complete'] })],
producers: new Map([['msd-v', ['Verification Complete']]]),
});
assert.deepEqual(vs, []);
});
test('a roster agent with no registry row is agent_without_contract', () => {
const vs = run({
registry: [row('gsd-a', ['ALPHA COMPLETE'], 'sentinel-match')],
registry: [row('msd-a', ['ALPHA COMPLETE'], 'sentinel-match')],
producers: new Map([
['gsd-a', ['ALPHA COMPLETE']],
['gsd-orphan', []],
['msd-a', ['ALPHA COMPLETE']],
['msd-orphan', []],
]),
consumers: new Map([['gsd-core/workflows/w.md', 'x `## ALPHA COMPLETE`']]),
consumers: new Map([['msd-core/workflows/w.md', 'x `## ALPHA COMPLETE`']]),
});
assert.equal(vs.length, 1);
assert.equal(vs[0].kind, 'agent_without_contract');
assert.equal(vs[0].agent, 'gsd-orphan');
assert.equal(vs[0].agent, 'msd-orphan');
});
test('two rows for one agent are duplicate_registry_row', () => {
const vs = run({
registry: [
row('gsd-a', ['ALPHA COMPLETE'], 'sentinel-match'),
row('gsd-a', ['ALPHA RETRY'], 'sentinel-match'),
row('msd-a', ['ALPHA COMPLETE'], 'sentinel-match'),
row('msd-a', ['ALPHA RETRY'], 'sentinel-match'),
],
producers: new Map([['gsd-a', ['ALPHA COMPLETE', 'ALPHA RETRY']]]),
consumers: new Map([['gsd-core/workflows/w.md', '`## ALPHA COMPLETE` and `## ALPHA RETRY`']]),
producers: new Map([['msd-a', ['ALPHA COMPLETE', 'ALPHA RETRY']]]),
consumers: new Map([['msd-core/workflows/w.md', '`## ALPHA COMPLETE` and `## ALPHA RETRY`']]),
});
assert.equal(vs.length, 1);
assert.equal(vs[0].kind, 'duplicate_registry_row');
@@ -361,21 +361,21 @@ describe('contract-drift: contractViolations', () => {
test('a row naming an agent with no file is unknown_producer, without per-marker noise', () => {
const vs = run({
registry: [
row('gsd-ghost', ['GHOST COMPLETE'], 'sentinel-match'),
row('gsd-real', [], 'artifact+query'),
row('msd-ghost', ['GHOST COMPLETE'], 'sentinel-match'),
row('msd-real', [], 'artifact+query'),
],
producers: new Map([['gsd-real', []]]),
producers: new Map([['msd-real', []]]),
});
assert.deepEqual(kindsOf(vs), ['unknown_producer']);
});
test('a file-shaped Consumed by entry that resolves to nothing is unknown_consumer', () => {
const vs = run({
registry: [row('gsd-a', ['ALPHA COMPLETE'], 'sentinel-match', {
consumed_by: '`gsd-core/workflows/missing.md`, `gsd-core/workflows/real.md`',
registry: [row('msd-a', ['ALPHA COMPLETE'], 'sentinel-match', {
consumed_by: '`msd-core/workflows/missing.md`, `msd-core/workflows/real.md`',
})],
producers: new Map([['gsd-a', ['ALPHA COMPLETE']]]),
consumers: new Map([['gsd-core/workflows/real.md', '`## ALPHA COMPLETE`']]),
producers: new Map([['msd-a', ['ALPHA COMPLETE']]]),
consumers: new Map([['msd-core/workflows/real.md', '`## ALPHA COMPLETE`']]),
});
assert.deepEqual(kindsOf(vs), ['unknown_consumer']);
});
@@ -388,8 +388,8 @@ describe('contract-drift: contractViolations', () => {
const vs = run({
registry: [],
producers: new Map([
['gsd-a', []],
['gsd-b', []],
['msd-a', []],
['msd-b', []],
]),
});
assert.deepEqual(kindsOf(vs), ['agent_without_contract']);
@@ -399,32 +399,32 @@ describe('contract-drift: contractViolations', () => {
test('14 valid entries plus 1 broken yields exactly one violation and it is the broken one', () => {
const registry = [];
const producers = new Map();
const consumers = new Map([['gsd-core/workflows/w.md', '']]);
const consumers = new Map([['msd-core/workflows/w.md', '']]);
for (let i = 0; i < 14; i++) {
const m = `M${i} COMPLETE`;
registry.push(row(`gsd-${i}`, [m], 'sentinel-match'));
producers.set(`gsd-${i}`, [m]);
consumers.set('gsd-core/workflows/w.md', consumers.get('gsd-core/workflows/w.md') + ` \`${m}\``);
registry.push(row(`msd-${i}`, [m], 'sentinel-match'));
producers.set(`msd-${i}`, [m]);
consumers.set('msd-core/workflows/w.md', consumers.get('msd-core/workflows/w.md') + ` \`${m}\``);
}
registry.push(row('gsd-broken', ['BROKEN COMPLETE'], 'sentinel-match'));
producers.set('gsd-broken', []);
registry.push(row('msd-broken', ['BROKEN COMPLETE'], 'sentinel-match'));
producers.set('msd-broken', []);
const vs = run({ registry, producers, consumers });
assert.equal(vs.length, 1);
assert.equal(vs[0].kind, 'declared_marker_not_emitted');
assert.equal(vs[0].agent, 'gsd-broken');
assert.equal(vs[0].agent, 'msd-broken');
});
test('two producers with case-variant tokens produce case_collision, never auto-resolved', () => {
const vs = run({
registry: [
row('gsd-a', ['SYNTHESIS COMPLETE'], 'sentinel-match'),
row('gsd-b', ['Synthesis Complete'], 'sentinel-match'),
row('msd-a', ['SYNTHESIS COMPLETE'], 'sentinel-match'),
row('msd-b', ['Synthesis Complete'], 'sentinel-match'),
],
producers: new Map([
['gsd-a', ['SYNTHESIS COMPLETE']],
['gsd-b', ['Synthesis Complete']],
['msd-a', ['SYNTHESIS COMPLETE']],
['msd-b', ['Synthesis Complete']],
]),
consumers: new Map([['gsd-core/workflows/w.md', '`## SYNTHESIS COMPLETE` `## Synthesis Complete`']]),
consumers: new Map([['msd-core/workflows/w.md', '`## SYNTHESIS COMPLETE` `## Synthesis Complete`']]),
});
assert.equal(vs.length, 2);
assert.ok(vs.every((v) => v.kind === 'case_collision'));
@@ -432,33 +432,33 @@ describe('contract-drift: contractViolations', () => {
test('a case-insensitive-only match is case_only_match, not satisfied', () => {
const vs = run({
registry: [row('gsd-a', ['ALPHA COMPLETE'], 'sentinel-match')],
producers: new Map([['gsd-a', ['ALPHA COMPLETE']]]),
consumers: new Map([['gsd-core/workflows/w.md', 'then the alpha complete step runs']]),
registry: [row('msd-a', ['ALPHA COMPLETE'], 'sentinel-match')],
producers: new Map([['msd-a', ['ALPHA COMPLETE']]]),
consumers: new Map([['msd-core/workflows/w.md', 'then the alpha complete step runs']]),
});
assert.deepEqual(kindsOf(vs), ['case_only_match']);
});
test('a token appearing only in ordinary prose must not satisfy the contract', () => {
const vs = run({
registry: [row('gsd-a', ['VERIFICATION COMPLETE'], 'sentinel-match')],
producers: new Map([['gsd-a', ['VERIFICATION COMPLETE']]]),
consumers: new Map([['gsd-core/workflows/w.md', 'Once verification complete, proceed.']]),
registry: [row('msd-a', ['VERIFICATION COMPLETE'], 'sentinel-match')],
producers: new Map([['msd-a', ['VERIFICATION COMPLETE']]]),
consumers: new Map([['msd-core/workflows/w.md', 'Once verification complete, proceed.']]),
});
assert.deepEqual(kindsOf(vs), ['case_only_match']);
});
test('an unconsumed marker is exempt from the consumer check but still emitted-checked', () => {
const ok = run({
registry: [row('gsd-c', [], 'sentinel-match', { unconsumed_markers: ['GAMMA DRAFT'] })],
producers: new Map([['gsd-c', ['GAMMA DRAFT']]]),
registry: [row('msd-c', [], 'sentinel-match', { unconsumed_markers: ['GAMMA DRAFT'] })],
producers: new Map([['msd-c', ['GAMMA DRAFT']]]),
consumers: new Map(),
});
assert.deepEqual(ok, []);
const missingEmission = run({
registry: [row('gsd-c', [], 'sentinel-match', { unconsumed_markers: ['GAMMA DRAFT'] })],
producers: new Map([['gsd-c', []]]),
registry: [row('msd-c', [], 'sentinel-match', { unconsumed_markers: ['GAMMA DRAFT'] })],
producers: new Map([['msd-c', []]]),
});
assert.deepEqual(kindsOf(missingEmission), ['declared_marker_not_emitted']);
assert.equal(missingEmission[0].marker, 'GAMMA DRAFT');
@@ -467,23 +467,23 @@ describe('contract-drift: contractViolations', () => {
test('an unconsumed marker still participates in case-collision detection', () => {
const vs = run({
registry: [
row('gsd-a', ['GAMMA DRAFT'], 'sentinel-match'),
row('gsd-c', [], 'sentinel-match', { unconsumed_markers: ['Gamma Draft'] }),
row('msd-a', ['GAMMA DRAFT'], 'sentinel-match'),
row('msd-c', [], 'sentinel-match', { unconsumed_markers: ['Gamma Draft'] }),
],
producers: new Map([
['gsd-a', ['GAMMA DRAFT']],
['gsd-c', ['Gamma Draft']],
['msd-a', ['GAMMA DRAFT']],
['msd-c', ['Gamma Draft']],
]),
consumers: new Map([['gsd-core/workflows/w.md', '`## GAMMA DRAFT`']]),
consumers: new Map([['msd-core/workflows/w.md', '`## GAMMA DRAFT`']]),
});
assert.ok(vs.some((v) => v.kind === 'case_collision' && v.marker === 'Gamma Draft'));
});
test('an emitted-but-undeclared candidate is emitted_marker_not_declared, deduped per marker', () => {
const vs = run({
registry: [row('gsd-a', [], 'sentinel-match')],
producers: new Map([['gsd-a', []]]),
candidates: new Map([['gsd-a', ['MYSTERY COMPLETE', 'MYSTERY COMPLETE']]]),
registry: [row('msd-a', [], 'sentinel-match')],
producers: new Map([['msd-a', []]]),
candidates: new Map([['msd-a', ['MYSTERY COMPLETE', 'MYSTERY COMPLETE']]]),
});
assert.equal(vs.length, 1);
assert.equal(vs[0].kind, 'emitted_marker_not_declared');
@@ -491,9 +491,9 @@ describe('contract-drift: contractViolations', () => {
test('an emitted marker on an artifact row is reported ONCE as vestigial, never also as undeclared', () => {
const vs = run({
registry: [row('gsd-a', [], 'artifact+query')],
producers: new Map([['gsd-a', ['MYSTERY COMPLETE']]]),
candidates: new Map([['gsd-a', ['MYSTERY COMPLETE']]]),
registry: [row('msd-a', [], 'artifact+query')],
producers: new Map([['msd-a', ['MYSTERY COMPLETE']]]),
candidates: new Map([['msd-a', ['MYSTERY COMPLETE']]]),
});
assert.equal(vs.length, 1);
assert.equal(vs[0].kind, 'vestigial_marker');
@@ -501,19 +501,19 @@ describe('contract-drift: contractViolations', () => {
test('an unknown Kind value is unknown_kind', () => {
const vs = run({
registry: [row('gsd-a', [], 'sometimes')],
producers: new Map([['gsd-a', []]]),
registry: [row('msd-a', [], 'sometimes')],
producers: new Map([['msd-a', []]]),
});
assert.deepEqual(kindsOf(vs), ['unknown_kind']);
});
test("a marker consumed somewhere but by none of the row's declared consumers is declared_consumer_no_match", () => {
const vs = run({
registry: [row('gsd-a', ['ALPHA COMPLETE'], 'sentinel-match', { consumed_by: '`gsd-core/workflows/w.md`' })],
producers: new Map([['gsd-a', ['ALPHA COMPLETE']]]),
registry: [row('msd-a', ['ALPHA COMPLETE'], 'sentinel-match', { consumed_by: '`msd-core/workflows/w.md`' })],
producers: new Map([['msd-a', ['ALPHA COMPLETE']]]),
consumers: new Map([
['gsd-core/workflows/w.md', 'no match here'],
['gsd-core/workflows/other.md', 'dispatch `## ALPHA COMPLETE`'],
['msd-core/workflows/w.md', 'no match here'],
['msd-core/workflows/other.md', 'dispatch `## ALPHA COMPLETE`'],
]),
});
assert.equal(vs.length, 1);
@@ -569,15 +569,15 @@ describe('contract-drift: typed surface', () => {
describe('contract-drift: parseConsumedByCell', () => {
test('backticked paths are extracted', () => {
assert.deepEqual(
parseConsumedByCell('`gsd-core/workflows/a.md`, `commands/gsd/b.md`'),
['gsd-core/workflows/a.md', 'commands/gsd/b.md'],
parseConsumedByCell('`msd-core/workflows/a.md`, `commands/msd/b.md`'),
['msd-core/workflows/a.md', 'commands/msd/b.md'],
);
});
test('globs, commands, and prose are ignored', () => {
assert.deepEqual(
parseConsumedByCell('`*-VERIFICATION.md` artifact + `gsd_run query verification.status` in `gsd-core/workflows/v.md`'),
['gsd-core/workflows/v.md'],
parseConsumedByCell('`*-VERIFICATION.md` artifact + `msd_run query verification.status` in `msd-core/workflows/v.md`'),
['msd-core/workflows/v.md'],
);
});
@@ -602,24 +602,24 @@ describe('contract-drift: parseConsumedByCell', () => {
// ─── readTagViolations ───────────────────────────────────────────────────────
describe('contract-drift: readTagViolations (the F8 arm)', () => {
const REG = [{ agent: 'gsd-a', consumed_by: '`gsd-core/workflows/w.md`' }];
const REG = [{ agent: 'msd-a', consumed_by: '`msd-core/workflows/w.md`' }];
test('a consumer emitting <required_reading> with no gate in the agent is read_tag_gate_missing', () => {
const vs = readTagViolations({
registry: REG,
agentTexts: new Map([['gsd-a', '# Agent\n\nNo gate mention.']]),
consumerTexts: new Map([['gsd-core/workflows/w.md', '<required_reading>\n- UI-SPEC.md\n</required_reading>']]),
agentTexts: new Map([['msd-a', '# Agent\n\nNo gate mention.']]),
consumerTexts: new Map([['msd-core/workflows/w.md', '<required_reading>\n- UI-SPEC.md\n</required_reading>']]),
});
assert.equal(vs.length, 1);
assert.equal(vs[0].kind, 'read_tag_gate_missing');
assert.equal(vs[0].agent, 'gsd-a');
assert.equal(vs[0].agent, 'msd-a');
});
test('an agent referencing the gate is satisfied', () => {
const vs = readTagViolations({
registry: REG,
agentTexts: new Map([['gsd-a', 'If the prompt contains a `<required_reading>` block, you MUST Read every file listed.']]),
consumerTexts: new Map([['gsd-core/workflows/w.md', '<required_reading>\n- X.md\n</required_reading>']]),
agentTexts: new Map([['msd-a', 'If the prompt contains a `<required_reading>` block, you MUST Read every file listed.']]),
consumerTexts: new Map([['msd-core/workflows/w.md', '<required_reading>\n- X.md\n</required_reading>']]),
});
assert.deepEqual(vs, []);
});
@@ -627,8 +627,8 @@ describe('contract-drift: readTagViolations (the F8 arm)', () => {
test('a consumer emitting no read tag imposes no gate requirement', () => {
const vs = readTagViolations({
registry: REG,
agentTexts: new Map([['gsd-a', 'nothing']]),
consumerTexts: new Map([['gsd-core/workflows/w.md', 'plain dispatch']]),
agentTexts: new Map([['msd-a', 'nothing']]),
consumerTexts: new Map([['msd-core/workflows/w.md', 'plain dispatch']]),
});
assert.deepEqual(vs, []);
});
@@ -637,7 +637,7 @@ describe('contract-drift: readTagViolations (the F8 arm)', () => {
const vs = readTagViolations({
registry: [],
agentTexts: new Map(),
consumerTexts: new Map([['agents/gsd-a.md', '<files_to_read>\n- x\n</files_to_read>']]),
consumerTexts: new Map([['agents/msd-a.md', '<files_to_read>\n- x\n</files_to_read>']]),
});
assert.deepEqual(
vs.map((v) => v.kind),
@@ -649,7 +649,7 @@ describe('contract-drift: readTagViolations (the F8 arm)', () => {
const vs = readTagViolations({
registry: REG,
agentTexts: new Map(),
consumerTexts: new Map([['gsd-core/workflows/w.md', '<required_reading>x</required_reading>']]),
consumerTexts: new Map([['msd-core/workflows/w.md', '<required_reading>x</required_reading>']]),
});
assert.deepEqual(vs, []);
});
@@ -660,7 +660,7 @@ describe('contract-drift: readTagViolations (the F8 arm)', () => {
describe('contract-drift: unmatchedConsumerTokens (the F9 arm)', () => {
test('a workflow matching a token no producer emits is unmatched_consumer_token', () => {
const vs = unmatchedConsumerTokens({
consumerTexts: new Map([['gsd-core/workflows/w.md', 'dispatch on `## PHANTOM COMPLETE`']]),
consumerTexts: new Map([['msd-core/workflows/w.md', 'dispatch on `## PHANTOM COMPLETE`']]),
vocabulary: new Set(['REAL COMPLETE']),
});
assert.equal(vs.length, 1);
@@ -670,7 +670,7 @@ describe('contract-drift: unmatchedConsumerTokens (the F9 arm)', () => {
test('a declared token is not a violation', () => {
const vs = unmatchedConsumerTokens({
consumerTexts: new Map([['gsd-core/workflows/w.md', 'dispatch on `## REAL COMPLETE`']]),
consumerTexts: new Map([['msd-core/workflows/w.md', 'dispatch on `## REAL COMPLETE`']]),
vocabulary: new Set(['REAL COMPLETE']),
});
assert.deepEqual(vs, []);
@@ -678,7 +678,7 @@ describe('contract-drift: unmatchedConsumerTokens (the F9 arm)', () => {
test('agents/ files are not scanned (self-description, not a dispatch)', () => {
const vs = unmatchedConsumerTokens({
consumerTexts: new Map([['agents/gsd-a.md', 'returns `## PHANTOM COMPLETE`']]),
consumerTexts: new Map([['agents/msd-a.md', 'returns `## PHANTOM COMPLETE`']]),
vocabulary: new Set(),
});
assert.deepEqual(vs, []);
@@ -686,7 +686,7 @@ describe('contract-drift: unmatchedConsumerTokens (the F9 arm)', () => {
test('NON_AGENT_TOKENS are exempt and the set is exactly the justified entries', () => {
const vs = unmatchedConsumerTokens({
consumerTexts: new Map([['commands/gsd/x.md', 'display `## GRAPHIFY BUILD COMPLETE`']]),
consumerTexts: new Map([['commands/msd/x.md', 'display `## GRAPHIFY BUILD COMPLETE`']]),
vocabulary: new Set(),
});
assert.deepEqual(vs, []);
@@ -697,7 +697,7 @@ describe('contract-drift: unmatchedConsumerTokens (the F9 arm)', () => {
test('mixed-case and long tokens are not flagged', () => {
const vs = unmatchedConsumerTokens({
consumerTexts: new Map([
['gsd-core/workflows/w.md', 'match `## Self-Check: FAILED` and `## ' + 'X'.repeat(61) + ' COMPLETE`'],
['msd-core/workflows/w.md', 'match `## Self-Check: FAILED` and `## ' + 'X'.repeat(61) + ' COMPLETE`'],
]),
vocabulary: new Set(),
});
@@ -706,7 +706,7 @@ describe('contract-drift: unmatchedConsumerTokens (the F9 arm)', () => {
test('double-quoted match instructions are scanned too', () => {
const vs = unmatchedConsumerTokens({
consumerTexts: new Map([['gsd-core/workflows/w.md', 'gsd_stall_watch "## PHANTOM COMPLETE"']]),
consumerTexts: new Map([['msd-core/workflows/w.md', 'msd_stall_watch "## PHANTOM COMPLETE"']]),
vocabulary: new Set(),
});
assert.equal(vs.length, 1);
@@ -781,12 +781,12 @@ describe('contract-drift: extractMarkers fence property (fast-check)', () => {
describe('contract-drift: end-to-end via check-contract-drift.cjs --root', () => {
function writeFixture(dir, { registryBody, agents, extraFiles }) {
fs.mkdirSync(path.join(dir, 'gsd-core', 'references'), { recursive: true });
fs.mkdirSync(path.join(dir, 'msd-core', 'references'), { recursive: true });
fs.mkdirSync(path.join(dir, 'agents'), { recursive: true });
fs.mkdirSync(path.join(dir, 'gsd-core', 'workflows'), { recursive: true });
fs.mkdirSync(path.join(dir, 'commands', 'gsd'), { recursive: true });
fs.mkdirSync(path.join(dir, 'msd-core', 'workflows'), { recursive: true });
fs.mkdirSync(path.join(dir, 'commands', 'msd'), { recursive: true });
fs.writeFileSync(
path.join(dir, 'gsd-core', 'references', 'agent-contracts.md'),
path.join(dir, 'msd-core', 'references', 'agent-contracts.md'),
['## Agent Registry', '', registryBody, ''].join('\n'),
);
for (const [name, body] of Object.entries(agents || {})) {
@@ -801,10 +801,10 @@ describe('contract-drift: end-to-end via check-contract-drift.cjs --root', () =>
const CLEAN_REGISTRY = [
'| Agent | Role | Completion Markers | Consumed by | Kind |',
'|-------|------|--------------------|--------------|------|',
'| gsd-alpha | Fixture | `## ALPHA COMPLETE` | `gsd-core/workflows/w.md` | sentinel-match |',
'| msd-alpha | Fixture | `## ALPHA COMPLETE` | `msd-core/workflows/w.md` | sentinel-match |',
].join('\n');
const CLEAN_AGENTS = {
'gsd-alpha.md': [
'msd-alpha.md': [
'# Alpha',
'',
'Return:',
@@ -819,7 +819,7 @@ describe('contract-drift: end-to-end via check-contract-drift.cjs --root', () =>
].join('\n'),
};
const CLEAN_EXTRA = {
'gsd-core/workflows/w.md': 'Dispatch on `## ALPHA COMPLETE`.\n\n<required_reading>\n- x.md\n</required_reading>\n',
'msd-core/workflows/w.md': 'Dispatch on `## ALPHA COMPLETE`.\n\n<required_reading>\n- x.md\n</required_reading>\n',
};
// --json: tests consume the typed surface (CONTRIBUTING raw-text-matching
@@ -835,7 +835,7 @@ describe('contract-drift: end-to-end via check-contract-drift.cjs --root', () =>
}
test('clean fixture exits 0', (t) => {
const dir = createTempDir('gsd-3565-clean-');
const dir = createTempDir('msd-3565-clean-');
t.after(() => cleanup(dir));
writeFixture(dir, { registryBody: CLEAN_REGISTRY, agents: CLEAN_AGENTS, extraFiles: CLEAN_EXTRA });
const r = runCheckJson(dir);
@@ -845,25 +845,25 @@ describe('contract-drift: end-to-end via check-contract-drift.cjs --root', () =>
});
test('planted unmatched sentinel fails and names the producer', (t) => {
const dir = createTempDir('gsd-3565-orphan-');
const dir = createTempDir('msd-3565-orphan-');
t.after(() => cleanup(dir));
writeFixture(dir, { registryBody: CLEAN_REGISTRY, agents: CLEAN_AGENTS, extraFiles: { 'gsd-core/workflows/w.md': 'No markers matched here.\n' } });
writeFixture(dir, { registryBody: CLEAN_REGISTRY, agents: CLEAN_AGENTS, extraFiles: { 'msd-core/workflows/w.md': 'No markers matched here.\n' } });
const r = runCheckJson(dir);
assert.equal(r.exitCode, 1);
assert.equal(r.report.status, 'violations');
const v = r.report.violations.find((x) => x.kind === 'no_consumer');
assert.ok(v, `expected no_consumer, got: ${JSON.stringify(r.report.violations)}`);
assert.equal(v.agent, 'gsd-alpha');
assert.equal(v.agent, 'msd-alpha');
assert.equal(v.marker, 'ALPHA COMPLETE');
});
test('planted reverse violation (consumer matches a phantom token) fails', (t) => {
const dir = createTempDir('gsd-3565-phantom-');
const dir = createTempDir('msd-3565-phantom-');
t.after(() => cleanup(dir));
writeFixture(dir, {
registryBody: CLEAN_REGISTRY,
agents: CLEAN_AGENTS,
extraFiles: { 'gsd-core/workflows/w.md': 'Dispatch on `## ALPHA COMPLETE` or `## PHANTOM COMPLETE`.\n' },
extraFiles: { 'msd-core/workflows/w.md': 'Dispatch on `## ALPHA COMPLETE` or `## PHANTOM COMPLETE`.\n' },
});
const r = runCheckJson(dir);
assert.equal(r.exitCode, 1);
@@ -873,22 +873,22 @@ describe('contract-drift: end-to-end via check-contract-drift.cjs --root', () =>
});
test('planted case collision fails', (t) => {
const dir = createTempDir('gsd-3565-collision-');
const dir = createTempDir('msd-3565-collision-');
t.after(() => cleanup(dir));
const registry = [
'| Agent | Role | Completion Markers | Consumed by | Kind |',
'|-------|------|--------------------|--------------|------|',
'| gsd-alpha | Fixture | `## ALPHA COMPLETE` | `gsd-core/workflows/w.md` | sentinel-match |',
'| gsd-beta | Fixture | `## Alpha Complete` | `gsd-core/workflows/w.md` | sentinel-match |',
'| msd-alpha | Fixture | `## ALPHA COMPLETE` | `msd-core/workflows/w.md` | sentinel-match |',
'| msd-beta | Fixture | `## Alpha Complete` | `msd-core/workflows/w.md` | sentinel-match |',
].join('\n');
const agents = {
...CLEAN_AGENTS,
'gsd-beta.md': '```\n## Alpha Complete\n```\n',
'msd-beta.md': '```\n## Alpha Complete\n```\n',
};
writeFixture(dir, {
registryBody: registry,
agents,
extraFiles: { 'gsd-core/workflows/w.md': '`## ALPHA COMPLETE` `## Alpha Complete`\n' },
extraFiles: { 'msd-core/workflows/w.md': '`## ALPHA COMPLETE` `## Alpha Complete`\n' },
});
const r = runCheckJson(dir);
assert.equal(r.exitCode, 1);
@@ -896,27 +896,27 @@ describe('contract-drift: end-to-end via check-contract-drift.cjs --root', () =>
});
test('roster agent missing from the registry fails and names the agent', (t) => {
const dir = createTempDir('gsd-3565-norow-');
const dir = createTempDir('msd-3565-norow-');
t.after(() => cleanup(dir));
writeFixture(dir, {
registryBody: CLEAN_REGISTRY,
agents: { ...CLEAN_AGENTS, 'gsd-unregistered.md': '# Unregistered\n' },
agents: { ...CLEAN_AGENTS, 'msd-unregistered.md': '# Unregistered\n' },
extraFiles: CLEAN_EXTRA,
});
const r = runCheckJson(dir);
assert.equal(r.exitCode, 1);
const v = r.report.violations.find((x) => x.kind === 'agent_without_contract');
assert.ok(v, `expected agent_without_contract, got: ${JSON.stringify(r.report.violations)}`);
assert.equal(v.agent, 'gsd-unregistered');
assert.equal(v.agent, 'msd-unregistered');
});
test('a planted legacy <files_to_read> in a workflow fails as legacy_read_tag', (t) => {
const dir = createTempDir('gsd-3565-legacytag-');
const dir = createTempDir('msd-3565-legacytag-');
t.after(() => cleanup(dir));
writeFixture(dir, {
registryBody: CLEAN_REGISTRY,
agents: CLEAN_AGENTS,
extraFiles: { 'gsd-core/workflows/w.md': '<files_to_read>\n- x.md\n</files_to_read>\n' },
extraFiles: { 'msd-core/workflows/w.md': '<files_to_read>\n- x.md\n</files_to_read>\n' },
});
const r = runCheckJson(dir);
assert.equal(r.exitCode, 1);
@@ -924,22 +924,22 @@ describe('contract-drift: end-to-end via check-contract-drift.cjs --root', () =>
});
test('a consumer emitting <required_reading> to a gate-less agent fails', (t) => {
const dir = createTempDir('gsd-3565-gate-');
const dir = createTempDir('msd-3565-gate-');
t.after(() => cleanup(dir));
writeFixture(dir, {
registryBody: CLEAN_REGISTRY,
agents: { 'gsd-alpha.md': '# Alpha\n\nNo gate anywhere.\n\n```\n## ALPHA COMPLETE\n```\n' },
agents: { 'msd-alpha.md': '# Alpha\n\nNo gate anywhere.\n\n```\n## ALPHA COMPLETE\n```\n' },
extraFiles: CLEAN_EXTRA,
});
const r = runCheckJson(dir);
assert.equal(r.exitCode, 1);
const v = r.report.violations.find((x) => x.kind === 'read_tag_gate_missing');
assert.ok(v, `expected read_tag_gate_missing, got: ${JSON.stringify(r.report.violations)}`);
assert.equal(v.agent, 'gsd-alpha');
assert.equal(v.agent, 'msd-alpha');
});
test('a missing contracts file exits 1 with a named path', (t) => {
const dir = createTempDir('gsd-3565-nocontracts-');
const dir = createTempDir('msd-3565-nocontracts-');
t.after(() => cleanup(dir));
fs.mkdirSync(path.join(dir, 'agents'), { recursive: true });
const r = runCheck(dir);
@@ -948,13 +948,13 @@ describe('contract-drift: end-to-end via check-contract-drift.cjs --root', () =>
});
test('a malformed registry row fails as parse_error', (t) => {
const dir = createTempDir('gsd-3565-parseror-');
const dir = createTempDir('msd-3565-parseror-');
t.after(() => cleanup(dir));
writeFixture(dir, {
registryBody: [
'| Agent | Role | Completion Markers | Consumed by | Kind |',
'|-------|------|--------------------|--------------|------|',
'| gsd-alpha | Fixture | `## ALPHA COMPLETE` | `gsd-core/workflows/w.md` | sentinel-match |',
'| msd-alpha | Fixture | `## ALPHA COMPLETE` | `msd-core/workflows/w.md` | sentinel-match |',
'| broken row with too few cells |',
].join('\n'),
agents: CLEAN_AGENTS,
@@ -966,12 +966,12 @@ describe('contract-drift: end-to-end via check-contract-drift.cjs --root', () =>
});
test('an agent file with an unclosed fence fails as unclosed_fence', (t) => {
const dir = createTempDir('gsd-3565-fence-');
const dir = createTempDir('msd-3565-fence-');
t.after(() => cleanup(dir));
writeFixture(dir, {
registryBody: CLEAN_REGISTRY,
agents: {
'gsd-alpha.md': '# Alpha\n\n```\n## ALPHA COMPLETE\nnever closed\n',
'msd-alpha.md': '# Alpha\n\n```\n## ALPHA COMPLETE\nnever closed\n',
},
extraFiles: CLEAN_EXTRA,
});