a9a7a328e6
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.
547 lines
30 KiB
JavaScript
547 lines
30 KiB
JavaScript
/**
|
|
* msd-executor agent — MVP+TDD gate section contract
|
|
* Verifies the agent definition contains a section instructing the executor
|
|
* to halt and report when the runtime gate trips.
|
|
*/
|
|
const { test, describe } = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
|
|
const AGENT = path.join(__dirname, '..', 'agents', 'msd-executor.md');
|
|
const REF = path.join(__dirname, '..', 'msd-core', 'references', 'execute-mvp-tdd.md');
|
|
|
|
describe('msd-executor — MVP+TDD gate section', () => {
|
|
const content = fs.readFileSync(AGENT, 'utf-8');
|
|
|
|
test('agent defines a TDD Gate section keyed on TDD_MODE alone (#4011)', () => {
|
|
assert.match(content, /MVP\+TDD\s*Gate|MVP[\s-]?TDD[\s-]?gate|TDD\s*Gate/i, 'must label the gate');
|
|
// The gate's trigger must not require MVP_MODE (#4011): a discipline gate
|
|
// keyed to a product-scope flag is silently inert on non-MVP phases.
|
|
const gateSection = content.slice(
|
|
content.search(/## (?:MVP\+TDD )?TDD Gate/i),
|
|
content.indexOf('##', content.search(/## (?:MVP\+TDD )?TDD Gate/i) + 3),
|
|
);
|
|
assert.ok(!/MVP_MODE\s*=\s*"?"?true"?.{0,80}TDD_MODE|both .MVP_MODE.= true and .TDD_MODE.= true/i.test(gateSection),
|
|
'the executor gate section must trigger on TDD_MODE alone, not the MVP intersection (#4011)');
|
|
});
|
|
|
|
test('agent instructs halt-and-report when gate trips', () => {
|
|
assert.match(content, /halt|stop[^\n]*gate|gate[^\n]*halt/i, 'must instruct halt');
|
|
assert.match(content, /report|surface|emit/i, 'must instruct report');
|
|
});
|
|
|
|
test('agent references execute-mvp-tdd.md', () => {
|
|
assert.match(content, /execute-mvp-tdd\.md/, 'must reference the gate semantics file');
|
|
});
|
|
|
|
test('referenced file exists on disk', () => {
|
|
assert.ok(fs.existsSync(REF), `${REF} must exist`);
|
|
});
|
|
});
|
|
|
|
describe('msd-executor — state.* calls use the named-only router form (#1863 regression)', () => {
|
|
// The runtime state-command router (msd-core/bin/lib/state-command-router.cjs)
|
|
// parses record-metric / add-decision / add-blocker / record-session named-only
|
|
// via parseNamedArgs. Positional values are silently dropped, so state.cjs then
|
|
// throws its required-arg error and metrics/decisions/blockers/session continuity
|
|
// are never recorded. Each invocation in the executor agent must therefore pass
|
|
// the named flags the router expects (mirrors msd-core/workflows/execute-plan.md).
|
|
const content = fs.readFileSync(AGENT, 'utf-8');
|
|
|
|
// Capture a `msd_run query state.<cmd> ...` invocation, including backslash-continued lines.
|
|
function invocation(cmd) {
|
|
const re = new RegExp(String.raw`msd_run query state\.${cmd}\b(?:[^\r\n]*\\\r?\n)*[^\r\n]*`);
|
|
const m = content.match(re);
|
|
assert.ok(m, `executor must invoke state.${cmd}`);
|
|
return m[0];
|
|
}
|
|
|
|
test('record-metric passes --phase/--plan/--duration/--tasks/--files', () => {
|
|
const call = invocation('record-metric');
|
|
for (const flag of ['--phase', '--plan', '--duration', '--tasks', '--files']) {
|
|
assert.ok(call.includes(flag), `record-metric must pass ${flag}, got:\n${call}`);
|
|
}
|
|
});
|
|
|
|
test('add-decision passes --summary (or --summary-file)', () => {
|
|
assert.match(invocation('add-decision'), /--summary(?:-file)?\b/);
|
|
});
|
|
|
|
test('add-blocker passes --text (or --text-file)', () => {
|
|
assert.match(invocation('add-blocker'), /--text(?:-file)?\b/);
|
|
});
|
|
|
|
test('record-session passes --stopped-at and --resume-file', () => {
|
|
const call = invocation('record-session');
|
|
assert.ok(call.includes('--stopped-at'), 'record-session must pass --stopped-at');
|
|
assert.ok(call.includes('--resume-file'), 'record-session must pass --resume-file');
|
|
});
|
|
|
|
test('no state.* call leads with a bare positional (quoted) value — the #1863 bug', () => {
|
|
// Buggy multi-line form: `state.<cmd> \` then a line whose first token is a quote.
|
|
const continued = /state\.(?:record-metric|add-decision|add-blocker|record-session)\b[^\r\n]*\\\r?\n\s*"/;
|
|
assert.ok(!continued.test(content),
|
|
'state.* calls must lead with --flags, not a positional quoted value on the next line');
|
|
// Buggy same-line form: `state.<cmd> "..."`
|
|
const inline = /state\.(?:record-metric|add-decision|add-blocker|record-session)\s+"/;
|
|
assert.ok(!inline.test(content),
|
|
'state.* calls must not pass a positional value immediately after the command');
|
|
});
|
|
|
|
test('sibling workflow record-session calls also use named flags (#1863 completeness)', () => {
|
|
// The same named-only router backs milestone-summary.md and forensics.md; both
|
|
// previously passed record-session positionally (`"" "stopped-at" "resume-file"`),
|
|
// silently dropping the values. Guard them alongside the executor.
|
|
for (const rel of ['msd-core/workflows/milestone-summary.md', 'msd-core/workflows/forensics.md']) {
|
|
const wf = fs.readFileSync(path.join(__dirname, '..', rel), 'utf-8');
|
|
// eslint-disable-next-line local/no-unbounded-quantifier -- parses maintainer-authored workflow markdown, bounded prose, not adversarial input
|
|
const m = wf.match(/msd_run query state\.record-session\b(?:[^\r\n]*\\\r?\n)*[^\r\n]*/);
|
|
assert.ok(m, `${rel} must invoke state.record-session`);
|
|
assert.ok(m[0].includes('--stopped-at') && m[0].includes('--resume-file'),
|
|
`${rel} record-session must use --stopped-at/--resume-file, got:\n${m[0]}`);
|
|
assert.ok(!/state\.record-session\s+"/.test(wf),
|
|
`${rel} record-session must not lead with a positional value`);
|
|
}
|
|
});
|
|
});
|
|
|
|
|
|
// ────────────────────────────────────────────────────────────────────────
|
|
// Folded from tests/bug-3097-3099-executor-worktree-path-safety.test.cjs — consolidation epic #1969 (B7 #1976)
|
|
// ────────────────────────────────────────────────────────────────────────
|
|
{
|
|
const { describe: __foldDescribe } = require('node:test');
|
|
__foldDescribe("folded:bug-3097-3099-executor-worktree-path-safety (consolidation epic #1969 B7 #1976)", () => {
|
|
'use strict';
|
|
// allow-test-rule: source-text-is-the-product (see #3097)
|
|
// Reads markdown product files (msd-executor.md, worktree-path-safety.md) to
|
|
// verify structural protocol.
|
|
|
|
// Regression guards for bug #3097 and #3099.
|
|
//
|
|
// #3097: msd-executor's worktree HEAD guard used `if [ -f .git ]` to detect
|
|
// worktree mode. After a Bash `cd` out of the worktree into the main repo,
|
|
// `.git` is a DIRECTORY (not a file), so the test is false and the entire
|
|
// HEAD safety block is silently skipped. Commits then land on whatever branch
|
|
// the main repo has checked out — not the per-agent worktree branch.
|
|
//
|
|
// #3099: Executor agents construct absolute paths from `pwd` captured in the
|
|
// orchestrator context (main repo root). Edit/Write calls using these paths
|
|
// resolve to the main repo, not the worktree. git commit from the worktree
|
|
// sees a clean tree; the work is silently lost or leaks to main.
|
|
|
|
const { describe, test } = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('node:fs');
|
|
const path = require('node:path');
|
|
|
|
const ROOT = path.join(__dirname, '..');
|
|
const executorSrc = fs.readFileSync(
|
|
path.join(ROOT, 'agents', 'msd-executor.md'), 'utf8',
|
|
);
|
|
const executePhaseSrc = fs.readFileSync(
|
|
path.join(ROOT, 'msd-core', 'workflows', 'execute-phase.md'), 'utf8',
|
|
);
|
|
|
|
describe('bug #3097: cwd-drift sentinel in msd-executor.md', () => {
|
|
test('task_commit_protocol has cwd-drift assertion step (0a)', () => {
|
|
const protocolIdx = executorSrc.indexOf('<task_commit_protocol>');
|
|
const protocolEnd = executorSrc.indexOf('</task_commit_protocol>');
|
|
assert.ok(protocolIdx !== -1 && protocolEnd !== -1, 'task_commit_protocol block not found');
|
|
const protocol = executorSrc.slice(protocolIdx, protocolEnd);
|
|
assert.ok(
|
|
protocol.includes('cwd') || protocol.includes('drift') || protocol.includes('msd-spawn-toplevel'),
|
|
'task_commit_protocol missing cwd-drift assertion step — #3097 fix not applied',
|
|
);
|
|
});
|
|
|
|
test('sentinel uses git rev-parse --git-dir to detect worktree', () => {
|
|
const protocolIdx = executorSrc.indexOf('<task_commit_protocol>');
|
|
const protocolEnd = executorSrc.indexOf('</task_commit_protocol>');
|
|
const protocol = executorSrc.slice(protocolIdx, protocolEnd);
|
|
assert.ok(
|
|
protocol.includes('rev-parse --git-dir') || protocol.includes('worktrees/'),
|
|
'cwd-drift detection does not use git rev-parse --git-dir or .git/worktrees/ pattern',
|
|
);
|
|
});
|
|
|
|
test('cwd-drift check precedes HEAD assertion', () => {
|
|
const protocolIdx = executorSrc.indexOf('<task_commit_protocol>');
|
|
const protocolEnd = executorSrc.indexOf('</task_commit_protocol>');
|
|
const protocol = executorSrc.slice(protocolIdx, protocolEnd);
|
|
const driftIdx = protocol.search(/cwd.drift|msd-spawn-toplevel|drift.*assertion/i);
|
|
const headIdx = protocol.indexOf('Pre-commit HEAD safety assertion');
|
|
assert.ok(driftIdx !== -1, 'cwd-drift assertion not found');
|
|
assert.ok(headIdx !== -1, 'HEAD assertion not found');
|
|
assert.ok(driftIdx < headIdx, 'cwd-drift assertion must precede HEAD assertion (step 0a before step 0)');
|
|
});
|
|
});
|
|
|
|
describe('bug #3099: absolute-path safety guidance in msd-executor.md', () => {
|
|
test('task_commit_protocol documents absolute-path safety', () => {
|
|
const protocolIdx = executorSrc.indexOf('<task_commit_protocol>');
|
|
const protocolEnd = executorSrc.indexOf('</task_commit_protocol>');
|
|
const protocol = executorSrc.slice(protocolIdx, protocolEnd);
|
|
assert.ok(
|
|
(protocol.includes('absolute') || protocol.includes('absolute-path')) &&
|
|
(protocol.includes('worktree') || protocol.includes('WT_ROOT')),
|
|
'task_commit_protocol missing absolute-path safety guidance — #3099 fix not applied',
|
|
);
|
|
});
|
|
|
|
test('execute-phase.md parallel_execution block references path safety', () => {
|
|
const parallelIdx = executePhaseSrc.indexOf('<parallel_execution>');
|
|
assert.ok(parallelIdx !== -1, 'parallel_execution block not found in execute-phase.md');
|
|
// Verify the worktree-path-safety.md reference is present in the execution_context
|
|
// (loaded via @ reference rather than inlined — the safe extract pattern)
|
|
assert.ok(
|
|
executePhaseSrc.includes('worktree-path-safety.md'),
|
|
'execute-phase.md does not reference worktree-path-safety.md in execution_context',
|
|
);
|
|
});
|
|
|
|
test('execute-phase prompt anchors subagent file paths to project_root before required_reading (#280)', () => {
|
|
// Anchor on the dispatch's PROJECT_ROOT computation, then require the
|
|
// nearest <required_reading> block to open just before it — the executor
|
|
// must be told to compute the root BEFORE reading the listed files
|
|
// (#3423 note: execute-phase carries several such blocks, so a bare
|
|
// indexOf on the tag can anchor to the wrong one).
|
|
const prIdx = executePhaseSrc.indexOf('PROJECT_ROOT=$(git rev-parse --show-toplevel');
|
|
assert.ok(prIdx !== -1, 'executor dispatch must compute PROJECT_ROOT in the prompt');
|
|
const filesIdx = executePhaseSrc.lastIndexOf('<required_reading>', prIdx);
|
|
assert.ok(filesIdx !== -1, 'required_reading block not found before the PROJECT_ROOT computation');
|
|
assert.ok(prIdx - filesIdx < 1800, 'required_reading block must sit adjacent to the PROJECT_ROOT computation');
|
|
const dispatchSnippet = executePhaseSrc.slice(filesIdx, filesIdx + 1800);
|
|
assert.ok(
|
|
dispatchSnippet.includes('${PROJECT_ROOT}/'),
|
|
'executor required_reading paths must be anchored to ${PROJECT_ROOT}/',
|
|
);
|
|
});
|
|
|
|
test('worktree-path-safety.md reference file exists', () => {
|
|
assert.ok(
|
|
fs.existsSync(path.join(ROOT, 'msd-core', 'references', 'worktree-path-safety.md')),
|
|
'msd-core/references/worktree-path-safety.md does not exist',
|
|
);
|
|
});
|
|
|
|
test('worktree-path-safety.md contains cwd-drift and absolute-path guards', () => {
|
|
const safetySrc = fs.readFileSync(
|
|
path.join(ROOT, 'msd-core', 'references', 'worktree-path-safety.md'), 'utf8',
|
|
);
|
|
assert.ok(safetySrc.includes('msd-spawn-toplevel') || safetySrc.includes('cwd-drift'),
|
|
'worktree-path-safety.md missing cwd-drift sentinel content');
|
|
assert.ok(safetySrc.includes('WT_ROOT') || safetySrc.includes('absolute'),
|
|
'worktree-path-safety.md missing absolute-path guard content');
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
// ────────────────────────────────────────────────────────────────────────
|
|
// #4254 — sequential (non-isolated) executor dispatch had no hard pin to the
|
|
// orchestrator's own worktree root: the dispatched prompt told the executor to
|
|
// self-derive PROJECT_ROOT via `git rev-parse --show-toplevel`, and every
|
|
// existing guard (steps 0a/0b worktree-only, step 0 branch-scoped) is
|
|
// self-referential — so an executor spawned with a drifted cwd committed onto
|
|
// the wrong checkout silently. The fix ships a mode-agnostic "supplied-root
|
|
// pin" guard (step 0p) in worktree-path-safety.md, bound at dispatch time by
|
|
// execute-phase.md's SEQUENTIAL branch only (worktree mode keeps its own,
|
|
// intentionally different, self-derived root). These tests EXECUTE the shipped
|
|
// guard against real git fixtures — no string-only vacuity (#4296 review
|
|
// precedent, Blocker 2).
|
|
// ────────────────────────────────────────────────────────────────────────
|
|
describe('bug #4254: sequential executor supplied-root pin', () => {
|
|
// allow-test-rule: source-text-is-the-product (see #3097) — the reference
|
|
// and the workflow markdown ARE the product under test. ROOT and
|
|
// executePhaseSrc are re-declared here: the folded #3097/#3099 block above
|
|
// declares its own copies inside a closure, out of this describe's scope.
|
|
const ROOT = path.join(__dirname, '..');
|
|
const executePhaseSrc = fs.readFileSync(
|
|
path.join(ROOT, 'msd-core', 'workflows', 'execute-phase.md'), 'utf8',
|
|
);
|
|
const safetyRefPath = path.join(ROOT, 'msd-core', 'references', 'worktree-path-safety.md');
|
|
const pinStepPath = path.join(ROOT, 'msd-core', 'workflows', 'execute-phase', 'steps', 'sequential-root-pin.md');
|
|
const safetySrc = fs.readFileSync(safetyRefPath, 'utf8');
|
|
const pinStepSrc = fs.readFileSync(pinStepPath, 'utf8');
|
|
const { createTempGitProject, cleanup } = require('./helpers.cjs');
|
|
const { runHook } = require('./helpers/process-seam.cjs');
|
|
const { gitOrThrow } = require('./helpers/git-fixture.cjs');
|
|
const { HOOK_FANOUT_TIMEOUT_MS } = require('./helpers/timeouts.cjs');
|
|
|
|
const PIN_MARKER = '# msd:guard=supplied-root-pin';
|
|
|
|
// Extract the shipped guard — the exact ```bash block that carries the
|
|
// marker — so the tests can never pass against a stale or hand-copied body.
|
|
function extractPinGuard() {
|
|
const body = safetySrc.split('```bash\n').find((b) => b.startsWith(PIN_MARKER));
|
|
assert.ok(body, 'worktree-path-safety.md must ship the #4254 supplied-root-pin guard');
|
|
return body.split('```')[0].trim();
|
|
}
|
|
|
|
// The composition contract the orchestrator follows at dispatch: a
|
|
// shell-single-quoted literal with `'\''` escaping for embedded quotes.
|
|
const shellQuote = (v) => `'${String(v).replace(/'/g, `'\\''`)}'`;
|
|
|
|
function composeGuard(pinQuotedLiteral) {
|
|
return extractPinGuard().replace("PINNED_ROOT='{PINNED_ROOT}'", `PINNED_ROOT=${pinQuotedLiteral}`);
|
|
}
|
|
|
|
// Run the composed guard in `cwd`; `probe` (optional bash line) runs only if
|
|
// the guard passes — proving the write barrier, not just the exit code.
|
|
function runPinGuard(cwd, pin, probe) {
|
|
return runHook('-c', [composeGuard(shellQuote(pin)) + (probe ? `\n${probe}` : '')], {
|
|
interpreter: 'bash',
|
|
cwd,
|
|
timeoutMs: HOOK_FANOUT_TIMEOUT_MS,
|
|
env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
|
|
});
|
|
}
|
|
|
|
// Fixture: a primary checkout plus a linked worktree (the orchestrator's
|
|
// lane). Sibling path — a worktree inside the primary's tree would show up
|
|
// as an untracked directory and muddy the fixtures.
|
|
function makeOrchestratorLane(prefix) {
|
|
const primary = createTempGitProject(prefix);
|
|
const lane = `${primary}-orchestrator-wt`;
|
|
gitOrThrow(['worktree', 'add', '-q', '-b', 'phase/2-1', lane], { cwd: primary });
|
|
return { primary, lane };
|
|
}
|
|
|
|
test('#4254: reference ships the supplied-root pin section with composition + runtime contracts', () => {
|
|
assert.match(safetySrc, /## Supplied-root pin — step 0p \(#4254, EVERY mode\)/);
|
|
// Runtime contract: run before first Edit/Write and every commit; HALT on
|
|
// FATAL; warn-and-proceed ONLY when the prompt carries no pin block.
|
|
assert.match(safetySrc, /before your first Edit\/Write and again\s+before every commit/);
|
|
assert.match(safetySrc, /NO `<project_root_pin>` block[\s\S]*?warning line and continue/);
|
|
// The executor must never bind the placeholder itself — that is exactly
|
|
// the #4254 failure mode re-armored as a "fix".
|
|
assert.match(safetySrc, /Never bind\s+`\{PINNED_ROOT\}` yourself/);
|
|
// Composition contract: build-time literal substitution, single-quoted,
|
|
// git-vs-git comparison rationale (the #4296 Windows lesson).
|
|
assert.match(safetySrc, /substituting[\s\S]*`\{PINNED_ROOT\}`[\s\S]*shell-single-quoted/);
|
|
assert.match(safetySrc, /git-vs-git on BOTH sides/);
|
|
});
|
|
|
|
test('#4254: RED regression — drifted-cwd executor halts before the wrong-checkout write', () => {
|
|
const { primary, lane } = makeOrchestratorLane('msd-4254-drift-');
|
|
try {
|
|
// The orchestrator pinned its own lane; the executor's process cwd
|
|
// resolved to the PRIMARY checkout (the issue's exact shape).
|
|
const marker = path.join(primary, 'write-marker');
|
|
const res = runPinGuard(primary, lane, `printf 'W' > ${shellQuote(marker)}`);
|
|
assert.equal(res.exitCode, 1, `mismatched root must halt, got:\n${res.stdout}\n${res.stderr}`);
|
|
assert.equal(fs.existsSync(marker), false, 'no write may run after a root mismatch');
|
|
assert.match(res.stderr, /FATAL[^\n]*#4254/);
|
|
// Loud detection: the FATAL names BOTH roots — the pinned lane and the
|
|
// actual (wrong) primary checkout. The primary's basename is unique to
|
|
// it (the lane appends '-orchestrator-wt'), so matching it inside the
|
|
// Actual-root line proves the right checkout is being named.
|
|
assert.match(res.stderr, /Pinned root:[^\n]*orchestrator-wt/, 'FATAL must name the pinned root');
|
|
const { escapeRegex } = require('../msd-core/bin/lib/pattern.cjs');
|
|
const primaryName = escapeRegex(path.basename(primary));
|
|
assert.match(res.stderr, new RegExp(`Actual root:[^\\n]*${primaryName}`), 'FATAL must name the actual (wrong) root');
|
|
assert.doesNotMatch(res.stderr, new RegExp(`Actual root:[^\\n]*orchestrator-wt`), 'the actual root must NOT be the pinned lane');
|
|
// The FATAL self-describes its stage (and, on capture failures, git's own
|
|
// stderr) — the discriminator whose absence let this class of failure read
|
|
// as "capture returns empty" when the form gate was what fired on Windows.
|
|
assert.match(res.stderr, /Guard stage: root-mismatch/, 'drifted cwd is a root mismatch, not a capture or form failure');
|
|
assert.match(res.stderr, /Diagnostic: actual=.*pinned=.*superproject=<none>/, 'the mismatch diagnostic names both roots and the absent superproject');
|
|
} finally {
|
|
cleanup(primary);
|
|
}
|
|
});
|
|
|
|
test('#4254: correct-cwd control — matching root permits the write', () => {
|
|
const { primary, lane } = makeOrchestratorLane('msd-4254-match-');
|
|
try {
|
|
const marker = path.join(lane, 'write-marker');
|
|
const res = runPinGuard(lane, lane, `printf 'W' > ${shellQuote(marker)}`);
|
|
assert.equal(res.exitCode, 0, `matching root must permit the write, got:\n${res.stderr}`);
|
|
assert.equal(fs.readFileSync(marker, 'utf8'), 'W');
|
|
} finally {
|
|
cleanup(primary);
|
|
}
|
|
});
|
|
|
|
test('#4254: unexpanded or empty pin fails closed (never warn-and-proceed inside a pin block)', () => {
|
|
const { primary, lane } = makeOrchestratorLane('msd-4254-unbound-');
|
|
try {
|
|
const marker = path.join(lane, 'write-marker');
|
|
// Unexpanded: the orchestrator never performed the build-time substitution.
|
|
const unexpanded = runHook('-c', [extractPinGuard() + `\nprintf 'W' > ${shellQuote(marker)}`], {
|
|
interpreter: 'bash', cwd: lane, timeoutMs: HOOK_FANOUT_TIMEOUT_MS,
|
|
});
|
|
assert.equal(unexpanded.exitCode, 1, 'an unexpanded {PINNED_ROOT} must halt');
|
|
assert.match(unexpanded.stderr, /Guard stage: pin-unbound/, 'an unexpanded pin halts at the pin-unbound stage');
|
|
// Empty: substituted to nothing — indistinguishable from a forgotten transplant.
|
|
const empty = runHook('-c', [composeGuard("''") + `\nprintf 'W' > ${shellQuote(marker)}`], {
|
|
interpreter: 'bash', cwd: lane, timeoutMs: HOOK_FANOUT_TIMEOUT_MS,
|
|
});
|
|
assert.equal(empty.exitCode, 1, 'an empty pin must halt');
|
|
assert.match(empty.stderr, /Guard stage: pin-unbound/, 'an empty pin halts at the pin-unbound stage');
|
|
assert.equal(fs.existsSync(marker), false);
|
|
} finally {
|
|
cleanup(primary);
|
|
}
|
|
});
|
|
|
|
test('#4254: normalization — trailing slash, symlink alias, subdirectory cwd, and unresolved temp-root spelling all match', () => {
|
|
const { primary, lane } = makeOrchestratorLane('msd-4254-norm-');
|
|
try {
|
|
const alias = `${primary}-alias`;
|
|
fs.symlinkSync(lane, alias, 'junction');
|
|
const subdir = path.join(lane, 'nested');
|
|
fs.mkdirSync(subdir);
|
|
// The unresolved spelling of the temp root (macOS: /var/... vs git's
|
|
// resolved /private/var/...): both sides are git-emitted, so the
|
|
// comparison is representation-safe by construction. On platforms
|
|
// without the /var symlink this degenerates to the realpath form and
|
|
// still asserts the matching property.
|
|
const unresolvedLane = fs.realpathSync(lane).replace('/private/var/', '/var/');
|
|
for (const pin of [lane, `${lane}/`, alias, unresolvedLane]) {
|
|
const marker = path.join(lane, 'write-marker');
|
|
const res = runPinGuard(subdir, pin, `printf 'W' > ${shellQuote(marker)}`);
|
|
assert.equal(res.exitCode, 0, `pin form ${pin} must normalize to the same checkout:\n${res.stderr}`);
|
|
fs.unlinkSync(marker);
|
|
}
|
|
} finally {
|
|
cleanup(primary);
|
|
}
|
|
});
|
|
|
|
test('#4254: boundary — registered submodule of the pinned checkout commits; unregistered and sibling checkouts halt', () => {
|
|
const primary = createTempGitProject('msd-4254-super-');
|
|
const subSource = createTempGitProject('msd-4254-subsource-');
|
|
try {
|
|
gitOrThrow(['-c', 'protocol.file.allow=always', 'submodule', 'add', '-q', subSource, 'module'], { cwd: primary });
|
|
gitOrThrow(['commit', '-qm', 'chore: register submodule'], { cwd: primary });
|
|
const moduleRoot = path.join(primary, 'module');
|
|
// Registered immediate submodule: legitimate sub_repos work, permitted.
|
|
const inModule = path.join(moduleRoot, 'write-marker');
|
|
assert.equal(runPinGuard(moduleRoot, primary, `printf 'W' > ${shellQuote(inModule)}`).exitCode, 0);
|
|
fs.unlinkSync(inModule);
|
|
// Unregistered nested clone inside the pinned checkout: halts.
|
|
const rogue = path.join(primary, 'rogue-clone');
|
|
gitOrThrow(['clone', '-q', subSource, rogue], { cwd: primary });
|
|
const rogueMarker = path.join(rogue, 'write-marker');
|
|
assert.equal(runPinGuard(rogue, primary, `printf 'W' > ${shellQuote(rogueMarker)}`).exitCode, 1);
|
|
assert.equal(fs.existsSync(rogueMarker), false);
|
|
// Sibling linked worktree of the SAME repo (right repo, wrong checkout —
|
|
// the incident's exact shape): halts.
|
|
const sibling = `${primary}-sibling-wt`;
|
|
gitOrThrow(['worktree', 'add', '-q', '-b', 'phase/9-9', sibling], { cwd: primary });
|
|
const siblingMarker = path.join(sibling, 'write-marker');
|
|
assert.equal(runPinGuard(sibling, primary, `printf 'W' > ${shellQuote(siblingMarker)}`).exitCode, 1);
|
|
assert.equal(fs.existsSync(siblingMarker), false);
|
|
} finally {
|
|
cleanup(primary);
|
|
cleanup(subSource);
|
|
}
|
|
});
|
|
|
|
test('#4254: pin outside any git repo, and cwd outside any git repo, both fail closed', () => {
|
|
const { primary, lane } = makeOrchestratorLane('msd-4254-norepo-');
|
|
const outside = fs.mkdtempSync(path.join(require('node:os').tmpdir(), 'msd-4254-outside-'));
|
|
try {
|
|
assert.equal(runPinGuard(lane, outside).exitCode, 1, 'pin outside a repo must halt');
|
|
assert.equal(runPinGuard(outside, lane).exitCode, 1, 'cwd outside a repo must halt');
|
|
} finally {
|
|
cleanup(outside);
|
|
cleanup(primary);
|
|
}
|
|
});
|
|
|
|
test('#4254: shell-metacharacter pin is safely quoted — no command substitution executes', () => {
|
|
const { primary, lane } = makeOrchestratorLane('msd-4254-meta-');
|
|
try {
|
|
const tricky = path.join(primary, `q' $HOME $(touch PWNED) x`);
|
|
fs.symlinkSync(lane, tricky, 'junction');
|
|
const marker = path.join(lane, 'write-marker');
|
|
const res = runPinGuard(lane, tricky, `printf 'W' > ${shellQuote(marker)}`);
|
|
assert.equal(res.exitCode, 0, `quoted metacharacter pin must match its checkout:\n${res.stderr}`);
|
|
assert.equal(fs.existsSync(path.join(lane, 'PWNED')), false, 'command substitution in the pin must not execute');
|
|
assert.equal(fs.existsSync(marker), true);
|
|
} finally {
|
|
cleanup(primary);
|
|
}
|
|
});
|
|
|
|
test('#4254: relative pin is rejected; Windows drive-letter forms pass the form gate and fail only at the git lookup', () => {
|
|
const { primary, lane } = makeOrchestratorLane('msd-4254-forms-');
|
|
try {
|
|
// Relative pins are never trustworthy across cwds — rejected outright,
|
|
// and the FATAL says so at the form-gate stage.
|
|
const rel = runPinGuard(lane, 'relative/path');
|
|
assert.equal(rel.exitCode, 1);
|
|
assert.match(rel.stderr, /Guard stage: form-gate/, 'a relative pin must halt at the form gate');
|
|
// The drive-letter forms Windows produces must be ACCEPTED by the shipped
|
|
// guard's absolute-form gate and then fail only on the git lookup — never
|
|
// on the form rejection: the forward-slash form git EMITS (C:/…) and the
|
|
// backslash form Node's path.join and cmd.exe PRODUCE (C:\…, including
|
|
// RUNNER~1-style short names). The Guard stage line is the discriminator:
|
|
// pinned-capture means the form passed and `git -C` spoke (its stderr rides
|
|
// the Diagnostic line), form-gate means the gate ate the pin — the exact
|
|
// CI defect where every backslash pin died before the actual root was ever
|
|
// computed. Driving the SHIPPED guard also removes the hand-rolled
|
|
// duplicate `case` this row used to carry (the #4296 Minor 1 duplication
|
|
// smell, and itself a transit-fragile copy of the broken pattern).
|
|
for (const driveForm of ['C:/definitely/not/a/repo', 'C:\\definitely\\not\\a\\repo']) {
|
|
const res = runPinGuard(lane, driveForm);
|
|
assert.equal(res.exitCode, 1, `nonexistent drive-letter pin must fail closed (${driveForm})`);
|
|
assert.match(
|
|
res.stderr, /Guard stage: pinned-capture/,
|
|
`drive form ${driveForm} must pass the form gate and halt at the pinned-capture stage, got:\n${res.stderr}`,
|
|
);
|
|
assert.match(res.stderr, /Diagnostic: git -C <pinned root> rev-parse --show-toplevel failed:/, 'the capture failure carries git stderr');
|
|
}
|
|
// Transit hardening, pinned on the shipped text itself: the guard must
|
|
// generate its backslash comparator at RUNTIME (printf octal) and must not
|
|
// contain a doubled backslash anywhere — a backslash written twice does
|
|
// not survive the Windows command-line round-trip into bash (it arrives
|
|
// halved, rewriting any escape pattern that relies on it). Two earlier
|
|
// pattern spellings failed the Windows CI leg on exactly this.
|
|
const guardBody = extractPinGuard();
|
|
assert.doesNotMatch(guardBody, /\\\\/, 'the shipped guard must contain no doubled backslash (Windows transit halves it)');
|
|
assert.match(guardBody, /printf '\\134'/, 'the drive-form gate must generate its backslash comparator at runtime');
|
|
} finally {
|
|
cleanup(primary);
|
|
}
|
|
});
|
|
|
|
test('#4254: execute-phase.md sequential branch pins the orchestrator root at build time', () => {
|
|
const sequential = executePhaseSrc.split('**Sequential mode**')[1].split('4. **Wait for all agents')[0];
|
|
assert.ok(sequential.length > 0, 'sequential-mode section not found');
|
|
// The host step delegates the composition detail to the fragment (ADR-857
|
|
// Phase 6 frozen ceiling — execute-phase.md cannot grow) and the prompt
|
|
// gains the pin block plus the per-write/commit instruction.
|
|
assert.match(sequential, /read and execute\s+`execute-phase\/steps\/sequential-root-pin\.md`/);
|
|
assert.match(sequential, /<project_root_pin>/);
|
|
assert.match(sequential, /Run the `<project_root_pin>` guard before your first Edit\/Write and before every commit/);
|
|
// The fragment carries the full build-time embed contract.
|
|
assert.match(pinStepSrc, /ORCHESTRATOR build-time embed/);
|
|
assert.match(pinStepSrc, /\{PINNED_ROOT\}/);
|
|
assert.match(pinStepSrc, /ORCHESTRATOR_WT/);
|
|
assert.match(pinStepSrc, /do not pass this instruction through/i);
|
|
// The self-derivation is replaced with the literal, preserving the
|
|
// `PROJECT_ROOT=` binding the rest of <required_reading> depends on.
|
|
assert.match(pinStepSrc, /replace the self-derivation line/);
|
|
assert.match(pinStepSrc, /PROJECT_ROOT='<the same literal/);
|
|
// Scoping: the fragment must say worktree mode keeps the self-derived form.
|
|
assert.match(pinStepSrc, /sequential-mode\s+ONLY/i);
|
|
// The wave serialization rules moved with it, verbatim in substance.
|
|
assert.match(pinStepSrc, /two non-worktree plans in the same wave must serialize/);
|
|
});
|
|
|
|
test('#4254: worktree-mode dispatch is untouched — keeps self-derivation, gains no pin', () => {
|
|
const isolated = executePhaseSrc.slice(
|
|
executePhaseSrc.indexOf('<parallel_execution>'),
|
|
executePhaseSrc.indexOf('**Sequential mode**'),
|
|
);
|
|
assert.ok(isolated.length > 0, 'worktree-mode dispatch slice not found');
|
|
assert.match(isolated, /PROJECT_ROOT=\$\(git rev-parse --show-toplevel/, 'isolated executor keeps its own (correct) root derivation');
|
|
assert.doesNotMatch(isolated, /<project_root_pin>/, 'isolated prompt must not inherit the orchestrator root');
|
|
});
|
|
});
|