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.
570 lines
29 KiB
JavaScript
570 lines
29 KiB
JavaScript
// allow-test-rule: source-text-is-the-product
|
|
// Workflow .md / agent .md / command .md / reference .md files — their text
|
|
// IS what the runtime loads. Testing text content tests the deployed contract.
|
|
// Per CONTRIBUTING.md exception matrix.
|
|
'use strict';
|
|
|
|
|
|
const { describe, test } = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('node:fs');
|
|
const path = require('node:path');
|
|
const { scanFencedBlocks } = require('../msd-core/bin/lib/markdown-sectionizer.cjs');
|
|
|
|
describe('debug session management implementation', () => {
|
|
test('DEBUG.md template contains reasoning_checkpoint field', () => {
|
|
const content = fs.readFileSync(
|
|
path.join(process.cwd(), 'msd-core/templates/DEBUG.md'),
|
|
'utf8'
|
|
);
|
|
assert.ok(content.includes('reasoning_checkpoint'), 'DEBUG.md must contain reasoning_checkpoint field');
|
|
});
|
|
|
|
test('DEBUG.md template contains tdd_checkpoint field', () => {
|
|
const content = fs.readFileSync(
|
|
path.join(process.cwd(), 'msd-core/templates/DEBUG.md'),
|
|
'utf8'
|
|
);
|
|
assert.ok(content.includes('tdd_checkpoint'), 'DEBUG.md must contain tdd_checkpoint field');
|
|
});
|
|
|
|
test('debug command contains list subcommand logic', () => {
|
|
const content = fs.readFileSync(
|
|
path.join(process.cwd(), 'msd-core/workflows/debug.md'),
|
|
'utf8'
|
|
);
|
|
assert.ok(
|
|
content.includes('SUBCMD=list') || content.includes('"list"'),
|
|
'debug.md must contain list subcommand logic'
|
|
);
|
|
});
|
|
|
|
test('debug command contains continue subcommand logic', () => {
|
|
const content = fs.readFileSync(
|
|
path.join(process.cwd(), 'msd-core/workflows/debug.md'),
|
|
'utf8'
|
|
);
|
|
assert.ok(
|
|
content.includes('SUBCMD=continue') || content.includes('"continue"'),
|
|
'debug.md must contain continue subcommand logic'
|
|
);
|
|
});
|
|
|
|
test('debug command contains status subcommand logic', () => {
|
|
const content = fs.readFileSync(
|
|
path.join(process.cwd(), 'msd-core/workflows/debug.md'),
|
|
'utf8'
|
|
);
|
|
assert.ok(
|
|
content.includes('SUBCMD=status') || content.includes('"status"'),
|
|
'debug.md must contain status subcommand logic'
|
|
);
|
|
});
|
|
|
|
test('debug command contains TDD gate logic', () => {
|
|
const content = fs.readFileSync(
|
|
path.join(process.cwd(), 'msd-core/workflows/debug.md'),
|
|
'utf8'
|
|
);
|
|
assert.ok(
|
|
content.includes('TDD_MODE') || content.includes('tdd_mode'),
|
|
'debug.md must contain TDD gate logic'
|
|
);
|
|
});
|
|
|
|
test('debug.md reads tdd_mode via workflow.tdd_mode key (not bare tdd_mode)', () => {
|
|
const content = fs.readFileSync(
|
|
path.join(process.cwd(), 'msd-core/workflows/debug.md'),
|
|
'utf8'
|
|
);
|
|
// #3149: tdd_mode now arrives on the `init.debug` bundle rather than a
|
|
// `config-get` call in this workflow, so the old literal-call assertion no
|
|
// longer describes reality. The invariant it protected is unchanged and is
|
|
// asserted at its new home: `cmdInitDebug` resolves `config.workflow`'s
|
|
// `tdd_mode`, never a bare top-level key — proven behaviorally in
|
|
// tests/init-debug.test.cjs ('honors workflow.tdd_mode, ignores a bare
|
|
// top-level tdd_mode'). What must remain true HERE is only that this
|
|
// workflow never reintroduces a bare-key read of its own.
|
|
assert.ok(
|
|
!content.includes('config-get tdd_mode'),
|
|
'debug.md must not use bare "tdd_mode" key — use "workflow.tdd_mode" to match every other consumer'
|
|
);
|
|
assert.ok(
|
|
content.includes('tdd_mode'),
|
|
'debug.md must still consume tdd_mode (now from the init.debug bundle)'
|
|
);
|
|
});
|
|
|
|
test('debug command contains security hardening', () => {
|
|
const content = fs.readFileSync(
|
|
path.join(process.cwd(), 'msd-core/workflows/debug.md'),
|
|
'utf8'
|
|
);
|
|
assert.ok(content.includes('DATA_START'), 'debug.md must contain DATA_START injection boundary marker');
|
|
});
|
|
|
|
test('debug command surfaces next_action before spawn', () => {
|
|
const content = fs.readFileSync(
|
|
path.join(process.cwd(), 'msd-core/workflows/debug.md'),
|
|
'utf8'
|
|
);
|
|
assert.ok(
|
|
content.includes('[debug] Next:') || content.includes('next_action'),
|
|
'debug.md must surface next_action before agent spawn'
|
|
);
|
|
});
|
|
|
|
test('msd-debugger contains structured reasoning checkpoint', () => {
|
|
const content = fs.readFileSync(
|
|
path.join(process.cwd(), 'agents/msd-debugger.md'),
|
|
'utf8'
|
|
);
|
|
assert.ok(content.includes('reasoning_checkpoint'), 'msd-debugger.md must contain reasoning_checkpoint');
|
|
});
|
|
|
|
test('msd-debugger contains TDD checkpoint mode', () => {
|
|
const content = fs.readFileSync(
|
|
path.join(process.cwd(), 'agents/msd-debugger.md'),
|
|
'utf8'
|
|
);
|
|
assert.ok(content.includes('tdd_mode'), 'msd-debugger.md must contain tdd_mode');
|
|
assert.ok(content.includes('TDD CHECKPOINT'), 'msd-debugger.md must contain TDD CHECKPOINT return format');
|
|
});
|
|
|
|
test('msd-debugger contains delta debugging technique', () => {
|
|
const content = fs.readFileSync(
|
|
path.join(process.cwd(), 'agents/msd-debugger.md'),
|
|
'utf8'
|
|
);
|
|
assert.ok(content.includes('Delta Debugging'), 'msd-debugger.md must contain Delta Debugging technique');
|
|
});
|
|
|
|
test('msd-debugger contains security note about DATA_START', () => {
|
|
const content = fs.readFileSync(
|
|
path.join(process.cwd(), 'agents/msd-debugger.md'),
|
|
'utf8'
|
|
);
|
|
assert.ok(content.includes('DATA_START'), 'msd-debugger.md must contain DATA_START security reference');
|
|
});
|
|
});
|
|
|
|
// Tests for #2148 and #2151
|
|
describe('debug skill dispatch and sub-orchestrator (#2148, #2151)', () => {
|
|
test('msd-debugger ROOT CAUSE FOUND format includes specialist_hint field', () => {
|
|
const content = fs.readFileSync(path.join(process.cwd(), 'agents', 'msd-debugger.md'), 'utf8');
|
|
assert.ok(content.includes('specialist_hint'), 'msd-debugger missing specialist_hint in ROOT CAUSE FOUND');
|
|
assert.ok(content.includes('swift_concurrency'), 'msd-debugger missing specialist_hint derivation guidance');
|
|
});
|
|
|
|
test('debug.md orchestrator has specialist skill dispatch step', () => {
|
|
const content = fs.readFileSync(path.join(process.cwd(), 'msd-core/workflows/debug.md'), 'utf8');
|
|
assert.ok(content.includes('specialist_hint'), 'debug.md missing specialist dispatch logic');
|
|
assert.ok(content.includes('typescript-expert'), 'debug.md missing skill dispatch mapping');
|
|
});
|
|
|
|
test('debug.md specialist dispatch prompt uses DATA_START/DATA_END boundaries', () => {
|
|
const content = fs.readFileSync(path.join(process.cwd(), 'msd-core/workflows/debug.md'), 'utf8');
|
|
assert.ok(content.includes('DATA_START') && content.includes('DATA_END'),
|
|
'debug.md specialist dispatch prompt missing security boundaries');
|
|
});
|
|
|
|
test('msd-debug-session-manager agent exists with correct tools', () => {
|
|
const content = fs.readFileSync(path.join(process.cwd(), 'agents', 'msd-debug-session-manager.md'), 'utf8');
|
|
assert.ok(content.includes('Agent'), 'msd-debug-session-manager missing Agent tool');
|
|
assert.ok(content.includes('AskUserQuestion'), 'msd-debug-session-manager missing AskUserQuestion tool');
|
|
});
|
|
|
|
test('msd-debug-session-manager spawns debugger with Agent() dispatcher', () => {
|
|
const content = fs.readFileSync(path.join(process.cwd(), 'agents', 'msd-debug-session-manager.md'), 'utf8');
|
|
assert.ok(content.includes('\nAgent('), 'session manager must dispatch debugger with Agent(');
|
|
});
|
|
|
|
test('msd-debug-session-manager uses DATA_START/DATA_END for checkpoint responses', () => {
|
|
const content = fs.readFileSync(path.join(process.cwd(), 'agents', 'msd-debug-session-manager.md'), 'utf8');
|
|
assert.ok(content.includes('DATA_START') && content.includes('DATA_END'),
|
|
'msd-debug-session-manager missing security boundaries on checkpoint responses');
|
|
});
|
|
|
|
test('msd-debug-session-manager has compact summary output format', () => {
|
|
const content = fs.readFileSync(path.join(process.cwd(), 'agents', 'msd-debug-session-manager.md'), 'utf8');
|
|
assert.ok(content.includes('DEBUG SESSION COMPLETE'), 'session manager missing compact summary format');
|
|
});
|
|
|
|
test('msd-debug-session-manager includes anti-heredoc rule', () => {
|
|
const content = fs.readFileSync(path.join(process.cwd(), 'agents', 'msd-debug-session-manager.md'), 'utf8');
|
|
assert.ok(content.includes('heredoc'), 'session manager missing anti-heredoc rule');
|
|
});
|
|
|
|
test('debug.md delegates to msd-debug-session-manager', () => {
|
|
const content = fs.readFileSync(path.join(process.cwd(), 'msd-core', 'workflows', 'debug.md'), 'utf8');
|
|
assert.ok(content.includes('msd-debug-session-manager'),
|
|
'debug.md does not delegate to session manager');
|
|
});
|
|
|
|
test('DEBUG.md reasoning_checkpoint field-count claim matches msd-debugger.md YAML keys (parity)', () => {
|
|
// Parallel-surface drift guard (DEFECT.GENERATIVE-FIX): the field-count
|
|
// claim in the DEBUG.md section_rules prose must equal the number of keys
|
|
// enumerated in the msd-debugger.md reasoning_checkpoint YAML block.
|
|
// CRLF-safe regex/split per DEFECT.WINDOWS-TEST-PORTABILITY. Accepts either
|
|
// digit ("7-field") or word ("seven-field") count form.
|
|
const NUMWORDS = { one: 1, two: 2, three: 3, four: 4, five: 5, six: 6, seven: 7, eight: 8, nine: 9, ten: 10 };
|
|
const debugContent = fs.readFileSync(path.join(process.cwd(), 'msd-core', 'templates', 'DEBUG.md'), 'utf8');
|
|
const agentContent = fs.readFileSync(path.join(process.cwd(), 'agents', 'msd-debugger.md'), 'utf8');
|
|
const debugMatch = debugContent.match(/reasoning_checkpoint[^.\r\n]*?(\d+|one|two|three|four|five|six|seven|eight|nine|ten)-field structured reasoning record/i);
|
|
assert.ok(debugMatch, 'DEBUG.md must state a "N-field structured reasoning record" claim for reasoning_checkpoint');
|
|
const claimedCount = /^\d+$/.test(debugMatch[1]) ? parseInt(debugMatch[1], 10) : NUMWORDS[debugMatch[1].toLowerCase()];
|
|
assert.ok(typeof claimedCount === 'number', `unrecognized field-count token: ${debugMatch[1]}`);
|
|
const agentLines = agentContent.split(/\r?\n/);
|
|
let yamlBody = null;
|
|
for (const block of scanFencedBlocks(agentLines)) {
|
|
if (block.closeLineIdx === -1) continue;
|
|
const bodyLines = agentLines.slice(block.openLineIdx + 1, block.closeLineIdx);
|
|
const labelIdx = bodyLines.findIndex((l) => /^reasoning_checkpoint:\s*$/.test(l));
|
|
if (labelIdx !== -1) {
|
|
yamlBody = bodyLines.slice(labelIdx + 1).join('\n');
|
|
break;
|
|
}
|
|
}
|
|
assert.ok(yamlBody, 'msd-debugger.md must define a fenced reasoning_checkpoint YAML block');
|
|
const keys = new Set();
|
|
for (const line of yamlBody.split(/\r?\n/)) {
|
|
// Match 2-space-indented YAML keys (with OR without an inline value —
|
|
// array-valued keys like confirming_evidence: have no trailing space).
|
|
const m = line.match(/^ {2}([a-z_]+):/);
|
|
if (m) keys.add(m[1]);
|
|
}
|
|
assert.strictEqual(
|
|
keys.size,
|
|
claimedCount,
|
|
`parity drift: DEBUG.md claims ${claimedCount}-field but msd-debugger.md enumerates ${keys.size} keys (${[...keys].join(', ')}). Update BOTH surfaces together.`
|
|
);
|
|
});
|
|
|
|
// #2376: debug_file_path handed to the spawned msd-debug-session-manager
|
|
// must resolve regardless of that subagent's own cwd, which may differ
|
|
// from the orchestrator's — debug.md must reference the absolute
|
|
// {debug_dir} field from `state load`, not a bare .planning/debug/...
|
|
// literal, in both the `continue` and new-session Agent() spawns.
|
|
test('debug.md session_params reference {debug_dir}/{slug}.md, not bare .planning/debug/... literals (#2376)', () => {
|
|
const content = fs.readFileSync(path.join(process.cwd(), 'msd-core/workflows/debug.md'), 'utf8');
|
|
assert.ok(content.includes('debug_file_path: {debug_dir}/{SLUG}.md'),
|
|
'debug.md continue-subcommand spawn must reference {debug_dir}/{SLUG}.md, not a bare .planning/debug/{SLUG}.md literal');
|
|
assert.ok(content.includes('debug_file_path: {debug_dir}/{slug}.md'),
|
|
'debug.md new-session spawn must reference {debug_dir}/{slug}.md, not a bare .planning/debug/{slug}.md literal');
|
|
assert.ok(!content.includes('debug_file_path: .planning/debug/'),
|
|
'debug.md session_params must not hardcode .planning/debug/... as debug_file_path (#2376)');
|
|
});
|
|
});
|
|
|
|
// Tests for #2196 (folded from tests/fix-2196-debug-agent-handoff.test.cjs):
|
|
// the /msd-debug orchestrator misused the foreground session-manager Agent()
|
|
// spawn as a background task, then queried the returned agent ID via
|
|
// TaskOutput (which expects a task ID) — yielding "No task found with ID"
|
|
// and leaving the workflow waiting on a handoff that was never queryable,
|
|
// with no recovery. The fix makes debug.md state explicitly that the spawn
|
|
// is foreground/blocking, that an agent ID must never be passed to
|
|
// TaskOutput, and that a lost handoff must be recovered (preserve
|
|
// checkpoint + resume).
|
|
describe('#2196 debug.md session-manager spawn contract', () => {
|
|
// allow-test-rule: source-text-is-the-product (#2196)
|
|
const DEBUG_MD_2196 = path.join(__dirname, '..', 'msd-core', 'workflows', 'debug.md');
|
|
const content = fs.readFileSync(DEBUG_MD_2196, 'utf-8');
|
|
const sectionStart = content.indexOf('Session Management');
|
|
const section = sectionStart !== -1 ? content.slice(sectionStart) : '';
|
|
|
|
test('debug.md has the Session Management section', () => {
|
|
assert.notEqual(sectionStart, -1, 'debug.md must contain the Session Management section');
|
|
});
|
|
|
|
test('the session-manager spawn is declared foreground/blocking (not backgrounded)', () => {
|
|
assert.ok(/foreground/i.test(section) && /blocking/i.test(section),
|
|
'the Agent() spawn must be declared foreground and blocking so it is not polled');
|
|
});
|
|
|
|
test('an agent ID must not be passed to TaskOutput', () => {
|
|
assert.ok(/TaskOutput/.test(section),
|
|
'the contract must mention TaskOutput by name');
|
|
assert.ok(/agent ID is NOT a task ID|agent ID is not a task ID/i.test(section),
|
|
'the contract must state an agent ID is not a task ID');
|
|
});
|
|
|
|
test('a lost handoff has a recovery path (preserve checkpoint + resume)', () => {
|
|
// Pin the CANONICAL colon form — the retired /msd-debug hyphen syntax is
|
|
// rejected by the slash-command-namespace guard, so this must be /msd:debug.
|
|
assert.ok(/\/msd:debug continue \{slug\}/.test(section),
|
|
'the contract must point to /msd:debug continue {slug} (canonical colon form) as the resume path');
|
|
assert.ok(/do not claim|do NOT claim/i.test(section),
|
|
'the contract must forbid claiming a lost-handoff session is still running');
|
|
});
|
|
});
|
|
|
|
// Tests for #2257 (folded from tests/fix-2257-debug-nonterminal-resume.test.cjs):
|
|
// the /msd-debug orchestrator had no contract for a foreground
|
|
// msd-debug-session-manager return that is usable but non-terminal. Section 4
|
|
// "Session Management" (and the `continue` subcommand's return handling in
|
|
// Section 1c) recognized only two literal-string returns — `DEBUG SESSION
|
|
// COMPLETE` and `ABANDONED` — with no else branch. Any other return (e.g. a
|
|
// mid-investigation progress summary emitted when the manager's own
|
|
// turn/context budget runs out) matched neither and fell through to the user
|
|
// as if the debug session were complete, silently abandoning the
|
|
// investigation mid-flight.
|
|
//
|
|
// The fix defines an explicit non-terminal marker, `CONTINUE_REQUIRED`, that
|
|
// the session manager emits when it must stop before reaching a terminal
|
|
// state (distinct from the two terminal returns and from a genuine
|
|
// user-input/approval `CHECKPOINT REACHED`, which already correctly pauses
|
|
// via AskUserQuestion). The orchestrator treats anything that is not one of
|
|
// the two terminal markers as non-terminal and auto-resumes by re-spawning
|
|
// the session manager from the on-disk checkpoint, bounded by an anti-loop
|
|
// guard.
|
|
//
|
|
// Correction (orthogonal review): the first cut of the anti-loop guard
|
|
// required BOTH `next_action` AND `updated` to be unchanged across two
|
|
// resumes to detect no-progress — but `agents/msd-debugger.md` overwrites
|
|
// `updated` on every checkpoint write ("Update the file BEFORE taking
|
|
// action"), so `updated` changes every cycle and the AND-condition could
|
|
// never be true, making the guard dead (unbounded auto-resume / DoS
|
|
// regression). The corrected guard keys no-progress detection off
|
|
// `next_action` ALONE and adds an absolute, content-independent hard cap of
|
|
// 3 total auto-resumes per slug per `/msd:debug` invocation as the real
|
|
// termination bound.
|
|
describe('#2257 debug non-terminal session-manager return contract', () => {
|
|
const DEBUG_MD_2257 = path.join(__dirname, '..', 'msd-core', 'workflows', 'debug.md');
|
|
const SESSION_MANAGER_MD = path.join(__dirname, '..', 'agents', 'msd-debug-session-manager.md');
|
|
|
|
// allow-test-rule: source-text-is-the-product (#2257)
|
|
// workflow/agent prose IS the runtime contract under test
|
|
const debugContent = fs.readFileSync(DEBUG_MD_2257, 'utf-8');
|
|
// allow-test-rule: source-text-is-the-product (#2257)
|
|
// workflow/agent prose IS the runtime contract under test
|
|
const managerContent = fs.readFileSync(SESSION_MANAGER_MD, 'utf-8');
|
|
|
|
const section4Start = debugContent.indexOf('## 4. Session Management');
|
|
const section4 = section4Start !== -1 ? debugContent.slice(section4Start) : '';
|
|
|
|
const section1cStart = debugContent.indexOf('## 1c. CONTINUE subcommand');
|
|
const section1dStart = debugContent.indexOf('## 1d. Check Active Sessions');
|
|
const section1c =
|
|
section1cStart !== -1 && section1dStart !== -1
|
|
? debugContent.slice(section1cStart, section1dStart)
|
|
: '';
|
|
|
|
test('debug.md has Section 4 (Session Management) and Section 1c (CONTINUE subcommand)', () => {
|
|
assert.notEqual(section4Start, -1, 'debug.md must contain Section 4 Session Management');
|
|
assert.notEqual(section1cStart, -1, 'debug.md must contain Section 1c CONTINUE subcommand');
|
|
});
|
|
|
|
test('Section 4 has an exhaustive non-terminal branch that auto-resumes from the checkpoint', () => {
|
|
assert.ok(/CONTINUE_REQUIRED/.test(section4),
|
|
'Section 4 must reference the CONTINUE_REQUIRED non-terminal marker');
|
|
assert.ok(/ANYTHING ELSE/i.test(section4),
|
|
'Section 4 must exhaustively catch any return that is not one of the two terminal markers');
|
|
assert.ok(/AUTO-RESUME/i.test(section4) && /re-spawning/i.test(section4),
|
|
'Section 4 must auto-resume by re-spawning the session manager, not return control to the user');
|
|
assert.ok(/same.{0,20}slug/i.test(section4),
|
|
'Section 4 auto-resume must use the SAME slug/checkpoint as the original spawn');
|
|
});
|
|
|
|
test('Section 1c has the same exhaustive non-terminal auto-resume branch (not just the two literals)', () => {
|
|
assert.ok(/CONTINUE_REQUIRED/.test(section1c),
|
|
'Section 1c must reference the CONTINUE_REQUIRED non-terminal marker');
|
|
assert.ok(/ANYTHING ELSE/i.test(section1c),
|
|
'Section 1c must exhaustively catch any return that is not one of the two terminal markers');
|
|
assert.ok(/AUTO-RESUME/i.test(section1c) && /re-spawning/i.test(section1c),
|
|
'Section 1c must auto-resume by re-spawning the session manager, not return control to the user');
|
|
assert.ok(/same.{0,20}slug/i.test(section1c),
|
|
'Section 1c auto-resume must use the SAME slug/checkpoint as the original spawn (symmetric with Section 4)');
|
|
});
|
|
|
|
test('msd-debug-session-manager.md defines CONTINUE_REQUIRED distinct from the two terminal formats', () => {
|
|
assert.ok(/## CONTINUE_REQUIRED/.test(managerContent),
|
|
'the agent must define an explicit ## CONTINUE_REQUIRED return heading');
|
|
assert.ok(/## DEBUG SESSION COMPLETE/.test(managerContent),
|
|
'the terminal DEBUG SESSION COMPLETE format must still be present');
|
|
assert.ok(/ABANDONED/.test(managerContent),
|
|
'the terminal ABANDONED format must still be present');
|
|
assert.ok(/non-terminal/i.test(managerContent),
|
|
'the agent must characterize CONTINUE_REQUIRED as non-terminal');
|
|
assert.ok(/CHECKPOINT REACHED/.test(managerContent) && /distinct from/i.test(managerContent),
|
|
'CONTINUE_REQUIRED must be explicitly distinguished from the genuine user-input CHECKPOINT REACHED shape');
|
|
assert.ok(/\.planning\/debug\/\{slug\}\.md/.test(managerContent),
|
|
'CONTINUE_REQUIRED must reference the on-disk checkpoint path');
|
|
assert.ok(/next_action/.test(managerContent) && /status/.test(managerContent),
|
|
'CONTINUE_REQUIRED must reference the checkpoint status/next_action fields');
|
|
});
|
|
|
|
test('an anti-loop bound exists so repeated no-progress auto-resumes do not loop indefinitely', () => {
|
|
assert.ok(/anti-loop guard/i.test(section4),
|
|
'Section 4 must name an anti-loop guard');
|
|
assert.ok(/blocker report/i.test(section4),
|
|
'Section 4 must emit a blocker report to the user once the bound is exceeded, instead of looping forever');
|
|
|
|
assert.ok(/anti-loop guard/i.test(section1c),
|
|
'Section 1c must name an anti-loop guard');
|
|
});
|
|
|
|
test('the anti-loop guard has an absolute hard cap independent of no-progress detection (#2257 correction)', () => {
|
|
for (const [label, section] of [['Section 4', section4], ['Section 1c', section1c]]) {
|
|
assert.ok(/hard cap/i.test(section), `${label} must name an absolute hard cap`);
|
|
assert.ok(/\b3\b/.test(section) && /total auto-resumes/i.test(section),
|
|
`${label} must encode a concrete numeric cap of 3 total auto-resumes`);
|
|
assert.ok(/regardless/i.test(section),
|
|
`${label} hard cap must trip regardless of whether next_action changed (content-independent)`);
|
|
}
|
|
});
|
|
|
|
test('no-progress detection keys off next_action alone, never the always-changing updated timestamp (#2257 correction)', () => {
|
|
for (const [label, section] of [['Section 4', section4], ['Section 1c', section1c]]) {
|
|
assert.ok(/next_action/.test(section),
|
|
`${label} no-progress heuristic must reference next_action`);
|
|
assert.ok(/(do not|never).{0,40}updated/i.test(section),
|
|
`${label} must explicitly forbid keying no-progress detection off updated`);
|
|
assert.ok(/changes every cycle/i.test(section),
|
|
`${label} must state WHY updated cannot be used: it is overwritten/changes every checkpoint cycle`);
|
|
}
|
|
});
|
|
});
|
|
|
|
// Tests for #3448 (folded into the owning module's test file per
|
|
// lint-regression-test-names): after a legitimate mid-investigation checkpoint is
|
|
// answered (e.g. a native permission prompt for the first focused RED command) and the
|
|
// session-manager instance returns non-terminal (## CONTINUE_REQUIRED — its own
|
|
// turn/context budget ran out), the orchestrator's auto-resume re-spawned
|
|
// msd-debug-session-manager with IDENTICAL session_params. The respawn was therefore
|
|
// prompt-indistinguishable from a cold start: the durable checkpoint's recorded
|
|
// next_action — read only for terminal classification and the blocker message — never
|
|
// reached the respawned agent, and neither did the fact that the earlier checkpoint had
|
|
// already been answered. Two auto-resumes then made no progress and the
|
|
// (correctly-behaving) no-progress guard stopped the loop, even though everything needed
|
|
// to proceed was on disk.
|
|
//
|
|
// The fix threads resume state through BOTH orchestrator call sites (Section 1c
|
|
// `continue` return handling and Section 4's non-terminal branch — textual duplicates,
|
|
// so fixing one leaves the other broken) and makes the manager's Step 2 msd-debugger
|
|
// template consume it, using Step 3d's DATA_START/DATA_END checkpoint-response shape.
|
|
// The anti-loop guard itself (next_action-only heuristic + absolute 3-resume hard cap)
|
|
// is deliberately NOT weakened — out of scope, confirmed correct.
|
|
describe('#3448 debug auto-resume must thread the recorded next_action', () => {
|
|
const debugContent3448 = fs.readFileSync(
|
|
path.join(__dirname, '..', 'msd-core', 'workflows', 'debug.md'),
|
|
'utf-8'
|
|
);
|
|
const managerContent3448 = fs.readFileSync(
|
|
path.join(__dirname, '..', 'agents', 'msd-debug-session-manager.md'),
|
|
'utf-8'
|
|
);
|
|
|
|
const section4Start3448 = debugContent3448.indexOf('## 4. Session Management');
|
|
const section43448 = section4Start3448 !== -1 ? debugContent3448.slice(section4Start3448) : '';
|
|
|
|
const section1cStart3448 = debugContent3448.indexOf('## 1c. CONTINUE subcommand');
|
|
const section1dStart3448 = debugContent3448.indexOf('## 1d. Check Active Sessions');
|
|
const section1c3448 =
|
|
section1cStart3448 !== -1 && section1dStart3448 !== -1
|
|
? debugContent3448.slice(section1cStart3448, section1dStart3448)
|
|
: '';
|
|
|
|
test('both auto-resume sections exist', () => {
|
|
assert.notEqual(section4Start3448, -1, 'debug.md must contain Section 4');
|
|
assert.notEqual(section1cStart3448, -1, 'debug.md must contain Section 1c');
|
|
});
|
|
|
|
// AC1 + AC3: the resume spawn must carry the checkpoint's recorded next_action,
|
|
// symmetrically across both resume trigger paths.
|
|
for (const [label, section] of [['Section 4', section43448], ['Section 1c', section1c3448]]) {
|
|
describe(`${label} resume spawn (#3448)`, () => {
|
|
test('forwards the recorded next_action into the resume spawn parameters', () => {
|
|
assert.ok(
|
|
/resume_next_action/i.test(section),
|
|
`${label} must pass the checkpoint's next_action into the respawn as an explicit resume parameter (not just read it for classification)`
|
|
);
|
|
assert.ok(
|
|
/next_action.{0,200}from.{0,40}\.planning\/debug\/\{sl?ug\}\.md/i.test(section) ||
|
|
/\.planning\/debug\/\{sl?ug\}\.md.{0,120}next_action/i.test(section),
|
|
`${label} must source resume_next_action from the on-disk checkpoint file`
|
|
);
|
|
});
|
|
|
|
test('forwards the checkpoint status so the respawn is not a cold start', () => {
|
|
assert.ok(
|
|
/resume_status/i.test(section),
|
|
`${label} must pass the checkpoint's status into the respawn`
|
|
);
|
|
});
|
|
|
|
test('resume spawn is explicitly NOT parameter-identical to the original spawn', () => {
|
|
assert.ok(
|
|
/not.{0,30}identical session_params|session_params.{0,80}plus|plus.{0,40}resume/i.test(section),
|
|
`${label} must append resume parameters to (not reuse verbatim) the original session_params — an identical-params respawn is the #3448 stall`
|
|
);
|
|
});
|
|
|
|
test('states the prior answered checkpoint must not be re-raised', () => {
|
|
assert.ok(
|
|
/already (been )?answered|answered checkpoint/i.test(section),
|
|
`${label} must carry the disposition that an earlier checkpoint was already answered, so the respawn does not re-raise it`
|
|
);
|
|
});
|
|
});
|
|
}
|
|
|
|
// AC1 + AC4: the manager must consume what the orchestrator now sends.
|
|
describe('msd-debug-session-manager.md consumes resume state (#3448)', () => {
|
|
test('session_parameters documents the resume parameters', () => {
|
|
assert.ok(/resume_next_action/i.test(managerContent3448),
|
|
'the session_parameters list must document resume_next_action');
|
|
assert.ok(/resume_status/i.test(managerContent3448),
|
|
'the session_parameters list must document resume_status');
|
|
});
|
|
|
|
test("Step 2's msd-debugger prompt conditionally carries the recorded next_action, DATA-bounded", () => {
|
|
const step2Start = managerContent3448.indexOf('## Step 2: Spawn msd-debugger Agent');
|
|
const step3Start = managerContent3448.indexOf('## Step 3: Handle Agent Return');
|
|
assert.ok(step2Start !== -1 && step3Start !== -1, 'Step 2 must exist');
|
|
const step2 = managerContent3448.slice(step2Start, step3Start);
|
|
assert.ok(
|
|
/resume_next_action/i.test(step2),
|
|
'Step 2 template must reference resume_next_action when present'
|
|
);
|
|
assert.ok(
|
|
/DATA_START[\s\S]{0,600}resume_next_action[\s\S]{0,600}DATA_END/i.test(step2),
|
|
'the forwarded next_action must be bounded by DATA_START/DATA_END (checkpoint content is data — Step 3d shape)'
|
|
);
|
|
});
|
|
|
|
test("Step 2 instructs the debugger to proceed directly on the recorded next action without re-raising answered checkpoints", () => {
|
|
const step2Start = managerContent3448.indexOf('## Step 2: Spawn msd-debugger Agent');
|
|
const step3Start = managerContent3448.indexOf('## Step 3: Handle Agent Return');
|
|
const step2 = managerContent3448.slice(step2Start, step3Start);
|
|
assert.ok(
|
|
/proceed (directly )?on|resume (from|with)|pick up/i.test(step2),
|
|
'Step 2 must tell the resumed debugger to act on the recorded next action'
|
|
);
|
|
assert.ok(
|
|
/already (been )?answered|do not re-?raise/i.test(step2),
|
|
'Step 2 must state that prior checkpoints were already answered and must not be re-raised'
|
|
);
|
|
});
|
|
});
|
|
|
|
// AC2: the circuit breaker must survive the fix unchanged.
|
|
describe('anti-loop guard unchanged by the #3448 fix (out-of-scope surface)', () => {
|
|
test('no-progress heuristic still keys off next_action alone with the 3-resume hard cap in both sections', () => {
|
|
for (const [label, section] of [['Section 4', section43448], ['Section 1c', section1c3448]]) {
|
|
assert.ok(/anti-loop guard/i.test(section), `${label} must still name the anti-loop guard`);
|
|
assert.ok(/\b3\b/.test(section) && /total auto-resumes/i.test(section),
|
|
`${label} must still encode the absolute 3-total-auto-resume hard cap`);
|
|
assert.ok(/next_action.{0,5}UNCHANGED/i.test(section),
|
|
`${label} no-progress detection must still compare next_action across resumes`);
|
|
}
|
|
});
|
|
|
|
test('resume directive must not suppress genuinely NEW human-input checkpoints', () => {
|
|
assert.ok(
|
|
/genuine|new human|pending user|AskUserQuestion/i.test(managerContent3448),
|
|
'the manager must still route genuine user-input checkpoints through AskUserQuestion (Step 3d), independent of resume dispatch'
|
|
);
|
|
});
|
|
});
|
|
});
|