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.
1228 lines
52 KiB
JavaScript
1228 lines
52 KiB
JavaScript
'use strict';
|
||
|
||
/**
|
||
* Unit tests for the smart-entry situation classifier.
|
||
*
|
||
* Spec: docs/superpowers/specs/2026-06-27-msd-smart-entry-design.md
|
||
*
|
||
* Covers: all 11 situations, priority ordering (paused beats blocked), JSON
|
||
* shape invariants (exactly one recommended, commands are /msd:* slash forms),
|
||
* and the --json / human output modes.
|
||
*/
|
||
|
||
const { describe, test, afterEach } = require('node:test');
|
||
const assert = require('node:assert/strict');
|
||
const fs = require('node:fs');
|
||
const os = require('node:os');
|
||
const path = require('node:path');
|
||
const { cleanup } = require('./helpers.cjs');
|
||
const { runNode } = require('./helpers/process-seam.cjs');
|
||
const { gitOrThrow, throwIfFailed } = require('./helpers/git-fixture.cjs');
|
||
const { PROBE_TIMEOUT_MS } = require('./helpers/timeouts.cjs');
|
||
|
||
const smartEntry = require('../msd-core/bin/lib/smart-entry.cjs');
|
||
const { classify, classifyProject, detectSignals, SITUATIONS } = smartEntry;
|
||
const TOOLS = path.join(__dirname, '..', 'msd-core', 'bin', 'msd-tools.cjs');
|
||
|
||
// ─── Fixture helpers ─────────────────────────────────────────────────────────
|
||
|
||
/**
|
||
* Create a temp dir with a `.planning/` and optional STATE.md / ROADMAP.md.
|
||
* @returns {string} tmpDir path
|
||
*/
|
||
function makeProject({ state, roadmap = false, git = false, verifyFail = false } = {}) {
|
||
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'msd-se-'));
|
||
fs.mkdirSync(path.join(tmpDir, '.planning', 'phases'), { recursive: true });
|
||
if (state !== undefined) {
|
||
fs.writeFileSync(path.join(tmpDir, '.planning', 'STATE.md'), state);
|
||
}
|
||
if (roadmap) {
|
||
// `roadmap === true` writes a minimal empty roadmap (no Progress table —
|
||
// the legacy test default). A string is written verbatim so tests can
|
||
// supply a real Progress table for the #2427 roadmap-derived completion
|
||
// check.
|
||
const content = typeof roadmap === 'string' ? roadmap : '# Roadmap\n';
|
||
fs.writeFileSync(path.join(tmpDir, '.planning', 'ROADMAP.md'), content);
|
||
}
|
||
if (git) {
|
||
gitOrThrow(['init'], { cwd: tmpDir });
|
||
gitOrThrow(['config', 'user.email', 't@t.com'], { cwd: tmpDir });
|
||
gitOrThrow(['config', 'user.name', 'T'], { cwd: tmpDir });
|
||
}
|
||
if (verifyFail) {
|
||
const phaseDir = path.join(tmpDir, '.planning', 'phases', '01-feat');
|
||
fs.mkdirSync(phaseDir, { recursive: true });
|
||
fs.writeFileSync(
|
||
path.join(phaseDir, 'SUMMARY.md'),
|
||
'# Summary\n\nSTATUS: blocked\n',
|
||
);
|
||
}
|
||
return tmpDir;
|
||
}
|
||
|
||
/** Minimal STATE.md frontmatter body. */
|
||
function state(opts) {
|
||
const fm = { ...opts };
|
||
// status goes in frontmatter as `status`; we also mirror as a body table for
|
||
// robustness against either format the real STATE.md uses.
|
||
const lines = ['---'];
|
||
for (const [k, v] of Object.entries(fm)) lines.push(`${k}: ${v}`);
|
||
lines.push('---', '', '# State', '');
|
||
if (fm.status) lines.push(`**Status:** ${fm.status}`);
|
||
return lines.join('\n') + '\n';
|
||
}
|
||
|
||
const CLEANUP = [];
|
||
function track(dir) {
|
||
CLEANUP.push(dir);
|
||
return dir;
|
||
}
|
||
function removeAll() {
|
||
for (const dir of CLEANUP) {
|
||
cleanup(dir);
|
||
}
|
||
CLEANUP.length = 0;
|
||
}
|
||
|
||
// ─── Tests ─────────────────────────────────────────────────────────────────────
|
||
|
||
describe('smart-entry: situation coverage', () => {
|
||
afterEach(removeAll);
|
||
|
||
const CASES = [
|
||
['no-project', () => {
|
||
// Truly empty dir — no .planning at all.
|
||
const d = fs.mkdtempSync(path.join(os.tmpdir(), 'msd-se-none-'));
|
||
return track(d);
|
||
}],
|
||
['paused', () => track(makeProject({ state: state({ status: 'planning', paused_at: '2026-06-01T00:00:00Z' }), roadmap: true }))],
|
||
['blocked', () => track(makeProject({ state: state({ status: 'executing', total_phases: 5, current_phase: 2 }) + '\n## Blockers\n\n- Need API key\n', roadmap: true }))],
|
||
['verify-failed', () => track(makeProject({ state: state({ status: 'verify-failed', total_phases: 5, current_phase: 2 }), roadmap: true, verifyFail: true }))],
|
||
['needs-first-phase', () => track(makeProject({ state: state({ status: 'planning', total_phases: 0, current_phase: 0 }) }))],
|
||
['planning', () => track(makeProject({ state: state({ status: 'planning', total_phases: 5, current_phase: 2 }), roadmap: true }))],
|
||
['executing', () => track(makeProject({ state: state({ status: 'executing', total_phases: 5, current_phase: 2, progress: 60 }), roadmap: true }))],
|
||
['verify-pending', () => track(makeProject({ state: state({ status: 'needs-review', total_phases: 5, current_phase: 2 }), roadmap: true }))],
|
||
['complete', () => track(makeProject({ state: state({ status: 'complete', total_phases: 5, current_phase: 5 }), roadmap: true }))],
|
||
['unknown', () => track(makeProject({ state: state({ status: '', total_phases: 5, current_phase: 2 }), roadmap: true }))],
|
||
];
|
||
|
||
for (const [expected, factory] of CASES) {
|
||
test(`classifies "${expected}"`, () => {
|
||
const dir = factory();
|
||
const result = classifyProject(dir);
|
||
assert.equal(result.situation, expected);
|
||
});
|
||
}
|
||
|
||
// #3860-family guard is NOT wanted here; these are #3864's missing pins:
|
||
// the classifier's verify branch must match the same verif* stem that
|
||
// state-document's normalizeStateStatus matches, or a STATE.md declaring
|
||
// `status: verified` falls through to `unknown` (and, on a clean tree with
|
||
// unpushed commits, to idle-stranded — differently wrong).
|
||
test('#3864: status "verified" classifies as verify-pending', () => {
|
||
const dir = track(makeProject({ state: state({ status: 'verified', total_phases: 5, current_phase: 2 }), roadmap: true }));
|
||
const result = classifyProject(dir);
|
||
assert.equal(result.situation, 'verify-pending');
|
||
});
|
||
|
||
test('#3864: status "verification" classifies as verify-pending', () => {
|
||
const dir = track(makeProject({ state: state({ status: 'verification', total_phases: 5, current_phase: 2 }), roadmap: true }));
|
||
const result = classifyProject(dir);
|
||
assert.equal(result.situation, 'verify-pending');
|
||
});
|
||
|
||
test('#3864: the stem does not over-match — "completed" still reaches complete', () => {
|
||
const dir = track(makeProject({ state: state({ status: 'completed', total_phases: 5, current_phase: 5 }), roadmap: true }));
|
||
const result = classifyProject(dir);
|
||
assert.equal(result.situation, 'complete');
|
||
});
|
||
|
||
test('#3864: "Phase complete — ready for verification" at 5/5 stays complete (complete beats a verif-bearing status)', () => {
|
||
// A real handler-written Status default (state-document.cts). It carries
|
||
// the verif stem but names COMPLETION — isComplete must win over the
|
||
// verify-pending branch when the project is actually done.
|
||
const dir = track(makeProject({ state: state({ status: 'Phase complete — ready for verification', total_phases: 5, current_phase: 5 }), roadmap: true }));
|
||
const result = classifyProject(dir);
|
||
assert.equal(result.situation, 'complete');
|
||
});
|
||
|
||
test('#3864: "Phase complete — ready for verification" mid-project is verify-pending', () => {
|
||
// Same real status word, phases remaining: pre-fix this fell through to
|
||
// unknown/idle-stranded (no "verify" substring); the stem now routes it.
|
||
const dir = track(makeProject({ state: state({ status: 'Phase complete — ready for verification', total_phases: 5, current_phase: 2 }), roadmap: true }));
|
||
const result = classifyProject(dir);
|
||
assert.equal(result.situation, 'verify-pending');
|
||
});
|
||
|
||
test('#3864: verify-failed still wins over the verify-pending stem (ordering pinned)', () => {
|
||
const dir = track(makeProject({ state: state({ status: 'verify-failed', total_phases: 5, current_phase: 2 }), roadmap: true, verifyFail: true }));
|
||
const result = classifyProject(dir);
|
||
assert.equal(result.situation, 'verify-failed');
|
||
});
|
||
|
||
test('SITUATIONS constant lists all 11 (incl unknown) and is frozen', () => {
|
||
assert.equal(SITUATIONS.length, 11);
|
||
assert.ok(SITUATIONS.includes('unknown'));
|
||
assert.ok(Object.isFrozen(SITUATIONS));
|
||
});
|
||
});
|
||
|
||
describe('smart-entry: idle-stranded (git-dependent)', () => {
|
||
afterEach(removeAll);
|
||
|
||
test('clean tree + unpushed commits → idle-stranded, recommended ship', () => {
|
||
// idle-stranded is the fallback AFTER the status predicates: it fires for an
|
||
// ambiguous status (matches none of planning/executing/verify/complete) with
|
||
// unpushed committed work. Use an empty status to land here deterministically.
|
||
const dir = track(makeProject({
|
||
state: state({ status: '', total_phases: 5, current_phase: 2 }),
|
||
roadmap: true,
|
||
git: true,
|
||
}));
|
||
// Commit the .planning files so the working tree is clean (untracked files
|
||
// would make git_dirty true and mask the stranded signal).
|
||
gitOrThrow(['add', '-A'], { cwd: dir });
|
||
gitOrThrow(['commit', '-m', 'init'], { cwd: dir });
|
||
const base = detectSignals(dir);
|
||
assert.equal(base.git_dirty, false);
|
||
assert.equal(base.git_unpushed, false);
|
||
|
||
// Force the stranded signal and assert the situation + recommendation.
|
||
const forced = { ...base, git_unpushed: true };
|
||
assert.equal(classify(forced), 'idle-stranded');
|
||
});
|
||
|
||
test('idle-stranded action set recommends ship', () => {
|
||
const dir = track(makeProject({
|
||
state: state({ status: '', total_phases: 5, current_phase: 2 }),
|
||
roadmap: true,
|
||
}));
|
||
const base = detectSignals(dir);
|
||
const forced = { ...base, git_unpushed: true };
|
||
const situation = classify(forced);
|
||
assert.equal(situation, 'idle-stranded');
|
||
const actions = smartEntry.actionsFor(situation, forced);
|
||
assert.equal(actions[0].id, 'ship');
|
||
assert.equal(actions[0].recommended, true);
|
||
assert.equal(actions[0].command, '/msd:ship');
|
||
});
|
||
});
|
||
|
||
describe('smart-entry: priority ordering', () => {
|
||
afterEach(removeAll);
|
||
|
||
test('verify-failed inspects current phase verify artifact', () => {
|
||
const dir = track(makeProject({
|
||
state: state({ status: 'executing', total_phases: 10, current_phase: 100 }),
|
||
roadmap: true,
|
||
}));
|
||
const phaseNinetyNine = path.join(dir, '.planning', 'phases', '99-old-phase');
|
||
const phaseOneHundred = path.join(dir, '.planning', 'phases', '100-current-phase');
|
||
fs.mkdirSync(phaseNinetyNine, { recursive: true });
|
||
fs.mkdirSync(phaseOneHundred, { recursive: true });
|
||
fs.writeFileSync(path.join(phaseNinetyNine, '99-VERIFICATION.md'), 'STATUS: passed\n');
|
||
fs.writeFileSync(path.join(phaseOneHundred, '100-VERIFICATION.md'), 'STATUS: failed\n');
|
||
|
||
const result = classifyProject(dir);
|
||
|
||
assert.equal(result.situation, 'verify-failed');
|
||
assert.equal(result.signals.verify_failed, true);
|
||
});
|
||
|
||
test('verify-failed ignores failure in a higher phase when state is on an earlier phase', () => {
|
||
const dir = track(makeProject({
|
||
state: state({ status: 'executing', total_phases: 10, current_phase: 2 }),
|
||
roadmap: true,
|
||
}));
|
||
const phaseTwo = path.join(dir, '.planning', 'phases', '02-active-phase');
|
||
const phaseOneHundred = path.join(dir, '.planning', 'phases', '100-leftover-phase');
|
||
fs.mkdirSync(phaseTwo, { recursive: true });
|
||
fs.mkdirSync(phaseOneHundred, { recursive: true });
|
||
fs.writeFileSync(path.join(phaseTwo, '02-VERIFICATION.md'), 'STATUS: passed\n');
|
||
fs.writeFileSync(path.join(phaseOneHundred, '100-VERIFICATION.md'), 'STATUS: failed\n');
|
||
|
||
const result = classifyProject(dir);
|
||
|
||
assert.equal(result.situation, 'executing');
|
||
assert.equal(result.signals.verify_failed, false);
|
||
});
|
||
|
||
test('verify-failed includes decimal phase directories for the current phase', () => {
|
||
const dir = track(makeProject({
|
||
state: state({ status: 'executing', total_phases: 10, current_phase: '7.1' }),
|
||
roadmap: true,
|
||
}));
|
||
const phaseSeven = path.join(dir, '.planning', 'phases', '07-base-phase');
|
||
const phaseSevenOne = path.join(dir, '.planning', 'phases', '07.1-inserted-phase');
|
||
fs.mkdirSync(phaseSeven, { recursive: true });
|
||
fs.mkdirSync(phaseSevenOne, { recursive: true });
|
||
fs.writeFileSync(path.join(phaseSeven, '07-VERIFICATION.md'), 'STATUS: passed\n');
|
||
fs.writeFileSync(path.join(phaseSevenOne, '07.1-VERIFICATION.md'), 'STATUS: failed\n');
|
||
|
||
const result = classifyProject(dir);
|
||
|
||
assert.equal(result.situation, 'verify-failed');
|
||
assert.equal(result.signals.verify_failed, true);
|
||
});
|
||
|
||
test('paused beats blocked (earlier row wins)', () => {
|
||
const dir = track(makeProject({
|
||
// paused_at set AND blockers present AND a phase loop: must resolve paused.
|
||
state: state({ status: 'executing', total_phases: 5, current_phase: 2, paused_at: '2026-06-01T00:00:00Z' })
|
||
+ '\n## Blockers\n\n- blocker one\n',
|
||
roadmap: true,
|
||
}));
|
||
const result = classifyProject(dir);
|
||
assert.equal(result.situation, 'paused');
|
||
});
|
||
|
||
test('blocked beats planning (earlier row wins)', () => {
|
||
const dir = track(makeProject({
|
||
state: state({ status: 'planning', total_phases: 5, current_phase: 2 })
|
||
+ '\n## Blockers\n\n- blocker one\n',
|
||
roadmap: true,
|
||
}));
|
||
const result = classifyProject(dir);
|
||
assert.equal(result.situation, 'blocked');
|
||
});
|
||
|
||
test('no-project beats everything (no .planning)', () => {
|
||
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'msd-se-empty-'));
|
||
track(tmpDir);
|
||
const result = classifyProject(tmpDir);
|
||
assert.equal(result.situation, 'no-project');
|
||
});
|
||
});
|
||
|
||
describe('smart-entry: real STATE.md schema (nested progress YAML + body Phase field)', () => {
|
||
afterEach(removeAll);
|
||
|
||
// Mirrors this repo's actual .planning/STATE.md: status + nested progress{}
|
||
// in frontmatter, phase number in the body as `Phase: N`. Codex review found
|
||
// the classifier originally misread this as needs-first-phase (#P1).
|
||
function realState({ status, phase, totalPhases, percent }) {
|
||
const fm = [
|
||
'---',
|
||
'msd_state_version: 1.0',
|
||
`status: ${status}`,
|
||
'last_activity: 2026-06-13',
|
||
'progress:',
|
||
` total_phases: ${totalPhases}`,
|
||
` percent: ${percent}`,
|
||
'---',
|
||
'',
|
||
'# Project State',
|
||
'',
|
||
`Phase: ${phase}`,
|
||
'',
|
||
`**Status:** ${status}`,
|
||
'',
|
||
].join('\n');
|
||
return fm;
|
||
}
|
||
|
||
test('reads current_phase from body `Phase:` + total_phases/percent from nested progress{}', () => {
|
||
const dir = track(makeProject({
|
||
state: realState({ status: 'verifying', phase: 3, totalPhases: 5, percent: 40 }),
|
||
roadmap: true,
|
||
}));
|
||
const signals = detectSignals(dir);
|
||
assert.equal(signals.current_phase, '3', 'current_phase from body Phase: field');
|
||
assert.equal(signals.total_phases, 5, 'total_phases from nested progress.total_phases');
|
||
assert.equal(signals.progress, 40, 'percent from nested progress.percent');
|
||
assert.equal(signals.status, 'verifying');
|
||
});
|
||
|
||
test('classifies verify-pending (not needs-first-phase) for an active real-schema project', () => {
|
||
const dir = track(makeProject({
|
||
state: realState({ status: 'verifying', phase: 3, totalPhases: 5, percent: 40 }),
|
||
roadmap: true,
|
||
}));
|
||
const result = classifyProject(dir);
|
||
assert.equal(result.situation, 'verify-pending');
|
||
// Forward motion delegates to the gated engine; verify-work stays available.
|
||
assert.equal(result.recommended, 'progress-next');
|
||
assert.match(result.summary, /Phase 3 of 5/);
|
||
});
|
||
|
||
test('executing status with nested progress schema classifies executing', () => {
|
||
const dir = track(makeProject({
|
||
state: realState({ status: 'executing', phase: 2, totalPhases: 5, percent: 60 }),
|
||
roadmap: true,
|
||
}));
|
||
const result = classifyProject(dir);
|
||
assert.equal(result.situation, 'executing');
|
||
// Forward motion delegates to /msd:progress --next, not a raw execute-phase.
|
||
assert.equal(result.recommended, 'progress-next');
|
||
});
|
||
});
|
||
|
||
describe('smart-entry: in-project advancement delegates to the gated engine', () => {
|
||
afterEach(removeAll);
|
||
|
||
// Reconciliation guard (#1787): /msd:next must not re-implement forward routing.
|
||
// For every in-project forward-motion situation the recommended action is
|
||
// `/msd:progress --next` (workflows/next.md), so Route 0's resume-incomplete
|
||
// -phase invariant + Gates 1-3 are never bypassed. Re-deriving advancement here
|
||
// is what got the old flat /msd-next removed (#3054). The specific command
|
||
// (execute-phase / plan-phase / verify-work) stays as an explicit secondary.
|
||
for (const situation of ['planning', 'executing', 'verify-pending']) {
|
||
test(`${situation}: recommended action is /msd:progress --next`, () => {
|
||
const signals = {
|
||
current_phase: 2, total_phases: 5, status: situation, progress: 40,
|
||
has_planning: true, has_roadmap: true, git_dirty: false, git_unpushed: false,
|
||
paused: false, blockers: [], has_git: true, verify_failed: false, stale_activity: false,
|
||
};
|
||
const actions = smartEntry.actionsFor(situation, signals);
|
||
const recommended = actions.filter((a) => a.recommended);
|
||
assert.equal(recommended.length, 1, 'exactly one recommended action');
|
||
assert.equal(recommended[0].command, '/msd:progress --next');
|
||
});
|
||
}
|
||
|
||
// Remediation / lifecycle situations are OFF the linear advance path — they
|
||
// keep direct specific recommendations (their distinct value over --next).
|
||
const DIRECT = {
|
||
'no-project': '/msd:new-project',
|
||
paused: '/msd:resume-work',
|
||
blocked: '/msd:debug',
|
||
'verify-failed': '/msd:verify-work',
|
||
'idle-stranded': '/msd:ship',
|
||
complete: '/msd:new-milestone',
|
||
};
|
||
for (const [situation, command] of Object.entries(DIRECT)) {
|
||
test(`${situation}: keeps its direct recommendation (${command})`, () => {
|
||
const signals = {
|
||
current_phase: 2, total_phases: 5, status: situation, progress: 40,
|
||
has_planning: true, has_roadmap: true, git_dirty: false, git_unpushed: false,
|
||
paused: false, blockers: [], has_git: true, verify_failed: false, stale_activity: false,
|
||
};
|
||
const actions = smartEntry.actionsFor(situation, signals);
|
||
const recommended = actions.find((a) => a.recommended);
|
||
assert.equal(recommended.command, command);
|
||
});
|
||
}
|
||
});
|
||
|
||
describe('smart-entry: per-situation action invariants (all 11)', () => {
|
||
// Lock the action-set contract for EVERY situation, not just the 6 sampled by
|
||
// the JSON-shape test: exactly one recommended, 1-4 actions, unique ids, and
|
||
// /msd:* command forms. Guards the reconciliation (and future edits) against
|
||
// silently breaking these for a less-common situation.
|
||
const sampleSignals = {
|
||
current_phase: 2, total_phases: 5, status: 'executing', progress: 60,
|
||
has_planning: true, has_roadmap: true, git_dirty: false, git_unpushed: false,
|
||
paused: false, blockers: [], has_git: true, verify_failed: false, stale_activity: false,
|
||
};
|
||
for (const situation of SITUATIONS) {
|
||
test(`${situation}: exactly one recommended, 1-4 unique-id /msd:* actions`, () => {
|
||
const actions = smartEntry.actionsFor(situation, sampleSignals);
|
||
assert.ok(actions.length >= 1 && actions.length <= 4, `${situation}: 1-4 actions (got ${actions.length})`);
|
||
assert.equal(actions.filter((a) => a.recommended).length, 1, `${situation}: exactly one recommended`);
|
||
const ids = actions.map((a) => a.id);
|
||
assert.equal(new Set(ids).size, ids.length, `${situation}: action ids are unique`);
|
||
for (const a of actions) {
|
||
assert.ok(a.command.startsWith('/msd:'), `${situation}/${a.id}: command is a /msd: slash form`);
|
||
}
|
||
});
|
||
}
|
||
});
|
||
|
||
describe('smart-entry: JSON shape invariants', () => {
|
||
afterEach(removeAll);
|
||
|
||
test('every situation yields exactly one recommended action and /msd:* commands', () => {
|
||
const dirs = [
|
||
track(makeProject()), // no-project
|
||
track(makeProject({ state: state({ status: 'planning', paused_at: '2026-06-01T00:00:00Z' }), roadmap: true })), // paused
|
||
track(makeProject({ state: state({ status: 'executing', total_phases: 5, current_phase: 2 }) + '\n## Blockers\n- b\n', roadmap: true })), // blocked
|
||
track(makeProject({ state: state({ status: 'executing', total_phases: 5, current_phase: 2, progress: 60 }), roadmap: true })), // executing
|
||
track(makeProject({ state: state({ status: 'complete', total_phases: 5, current_phase: 5 }), roadmap: true })), // complete
|
||
track(makeProject({ state: state({ status: '', total_phases: 5, current_phase: 2 }), roadmap: true })), // unknown
|
||
];
|
||
for (const dir of dirs) {
|
||
const result = classifyProject(dir);
|
||
const recommended = result.actions.filter((a) => a.recommended);
|
||
assert.equal(recommended.length, 1, `${result.situation}: exactly one recommended`);
|
||
assert.equal(recommended[0].id, result.recommended, `${result.situation}: recommended id matches`);
|
||
for (const a of result.actions) {
|
||
assert.ok(a.command.startsWith('/msd:'), `${result.situation}/${a.id}: command is a slash form`);
|
||
}
|
||
assert.ok(result.summary.length > 0, `${result.situation}: summary non-empty`);
|
||
assert.ok(result.actions.length >= 1 && result.actions.length <= 4, `${result.situation}: 1-4 actions`);
|
||
}
|
||
});
|
||
});
|
||
|
||
describe('smart-entry: CLI dispatch (msd-tools smart-entry)', () => {
|
||
afterEach(removeAll);
|
||
|
||
test('#4023: --json preserves decimal current_phase as a phase-id string', () => {
|
||
for (const phase of ['12.1', '12.10']) {
|
||
const dir = track(makeProject({
|
||
state: state({ status: 'executing', total_phases: 13, current_phase: phase }),
|
||
roadmap: true,
|
||
}));
|
||
const r = runNode([TOOLS, 'smart-entry', '--json', '--cwd', dir], { timeoutMs: PROBE_TIMEOUT_MS });
|
||
throwIfFailed(r, 'msd-tools smart-entry --json');
|
||
const out = JSON.parse(r.stdout);
|
||
assert.equal(out.signals.current_phase, phase);
|
||
}
|
||
});
|
||
|
||
test('--json in an empty dir returns no-project machine JSON', () => {
|
||
// A bare tmpdir with no .planning is a true no-project.
|
||
const bare = fs.mkdtempSync(path.join(os.tmpdir(), 'msd-se-bare-'));
|
||
track(bare);
|
||
const r = runNode([TOOLS, 'smart-entry', '--json', '--cwd', bare], { timeoutMs: PROBE_TIMEOUT_MS });
|
||
throwIfFailed(r, 'msd-tools smart-entry --json');
|
||
const j = JSON.parse(r.stdout);
|
||
assert.equal(j.situation, 'no-project');
|
||
assert.equal(j.recommended, 'new-project');
|
||
assert.equal(j.actions[0].command, '/msd:new-project');
|
||
});
|
||
|
||
test('default (human) mode prints a plain summary line, not JSON', () => {
|
||
const bare = fs.mkdtempSync(path.join(os.tmpdir(), 'msd-se-human-'));
|
||
track(bare);
|
||
const r = runNode([TOOLS, 'smart-entry', '--cwd', bare], { timeoutMs: PROBE_TIMEOUT_MS });
|
||
throwIfFailed(r, 'msd-tools smart-entry');
|
||
const out = r.stdout;
|
||
assert.ok(!out.startsWith('{'), 'human mode is not JSON');
|
||
assert.match(out, /No project yet/);
|
||
assert.match(out, /Recommended:/);
|
||
});
|
||
});
|
||
|
||
// ─── #2427: roadmap-grounded completion + tightened status regex ─────────────
|
||
//
|
||
// Pre-fix bug: isComplete compared global current_phase against stale
|
||
// milestone-scoped total_phases (written once at milestone-switch time) and
|
||
// matched any "shipped"/"done" substring in the status line — so a project
|
||
// mid-milestone with current_phase=7 > stale total_phases=4 AND a per-phase
|
||
// "Phase X shipped" status was falsely classified as "complete". The fix
|
||
// grounds completion in ROADMAP.md's Progress table (global, authoritative)
|
||
// and tightens the regex to require milestone-level language.
|
||
|
||
describe('#2427 — roadmap-grounded completion + tightened status regex', () => {
|
||
afterEach(removeAll);
|
||
|
||
/**
|
||
* Build a ROADMAP.md with a `## Progress` table of N rows, M of which are
|
||
* `Complete` and the rest `In Progress`. Matches the column-name-driven
|
||
* Progress table shape deriveProgressFromRoadmap scans.
|
||
*/
|
||
function roadmapWithProgress(total, completed) {
|
||
const rows = [];
|
||
for (let i = 1; i <= total; i++) {
|
||
const status = i <= completed ? 'Complete' : 'In Progress';
|
||
const phase = String(i).padStart(2, '0');
|
||
rows.push(`| ${phase} | 0/1 | ${status} | ${status === 'Complete' ? '2026-01-01' : ''} |`);
|
||
}
|
||
return [
|
||
'# Roadmap',
|
||
'',
|
||
'## Milestone v1.0',
|
||
'',
|
||
'## Progress',
|
||
'',
|
||
'| Phase | Plans Complete | Status | Completed |',
|
||
'|-------|---------------|--------|-----------|',
|
||
...rows,
|
||
].join('\n') + '\n';
|
||
}
|
||
|
||
test('mid-milestone with stale total_phases + unchecked roadmap phases is NOT complete', () => {
|
||
// The core bug: STATE.md says current_phase=7 >= total_phases=4 (stale,
|
||
// from a milestone switch when only 4 phases existed). Status contains
|
||
// "shipped" from a per-phase message. ROADMAP has 7 phases, only 4 done.
|
||
// MUST classify as something OTHER than "complete".
|
||
const dir = track(makeProject({
|
||
state: state({ status: 'Phase 7 shipped — PR #42', total_phases: 4, current_phase: 7 }),
|
||
roadmap: roadmapWithProgress(7, 4),
|
||
}));
|
||
const result = classifyProject(dir);
|
||
assert.notEqual(result.situation, 'complete',
|
||
`mid-milestone (7 phases, 4 done) must NOT be "complete" even with stale total_phases=4 + current_phase=7. Got: ${result.situation}`);
|
||
});
|
||
|
||
test('all roadmap phases complete classifies as complete even with stale cached total_phases', () => {
|
||
// ROADMAP says all 5 phases are done. STATE.md has stale total_phases=3
|
||
// (from an earlier milestone switch). The roadmap-derived check should
|
||
// win and classify as complete. Status uses ADR-2207's actual terminal
|
||
// written form "<version> milestone complete" (state-transition.cts:1303).
|
||
const dir = track(makeProject({
|
||
state: state({ status: 'v1.0 milestone complete', total_phases: 3, current_phase: 5 }),
|
||
roadmap: roadmapWithProgress(5, 5),
|
||
}));
|
||
const result = classifyProject(dir);
|
||
assert.equal(result.situation, 'complete',
|
||
`all roadmap phases complete must classify as "complete" regardless of stale cached total_phases. Got: ${result.situation}`);
|
||
});
|
||
|
||
test('per-phase "shipped" status alone does NOT satisfy the completion regex', () => {
|
||
// The pre-fix regex matched "shipped" as a standalone alternation branch.
|
||
// Tightened regex requires milestone-level language. With some phases
|
||
// unchecked AND status="shipped", must NOT be complete.
|
||
const dir = track(makeProject({
|
||
state: state({ status: 'shipped', total_phases: 5, current_phase: 5 }),
|
||
roadmap: roadmapWithProgress(5, 3),
|
||
}));
|
||
const result = classifyProject(dir);
|
||
assert.notEqual(result.situation, 'complete',
|
||
`status "shipped" alone (per-phase language) must NOT satisfy completion when roadmap has unchecked phases. Got: ${result.situation}`);
|
||
});
|
||
|
||
test('per-phase "done" status alone does NOT satisfy the completion regex', () => {
|
||
// Same as above but with "done" — the other over-broad branch the pre-fix
|
||
// regex matched.
|
||
const dir = track(makeProject({
|
||
state: state({ status: 'done', total_phases: 5, current_phase: 5 }),
|
||
roadmap: roadmapWithProgress(5, 3),
|
||
}));
|
||
const result = classifyProject(dir);
|
||
assert.notEqual(result.situation, 'complete',
|
||
`status "done" alone must NOT satisfy completion when roadmap has unchecked phases. Got: ${result.situation}`);
|
||
});
|
||
|
||
test('legacy fallback: empty roadmap still classifies via STATE.md comparison', () => {
|
||
// When ROADMAP.md has no Progress table (fresh project, non-standard
|
||
// layout), isComplete falls back to the legacy current_phase >= total_phases
|
||
// check. This preserves backward compat for projects that haven't adopted
|
||
// the Progress-table convention.
|
||
const dir = track(makeProject({
|
||
state: state({ status: 'complete', total_phases: 5, current_phase: 5 }),
|
||
roadmap: true, // empty roadmap — no Progress table
|
||
}));
|
||
const result = classifyProject(dir);
|
||
assert.equal(result.situation, 'complete',
|
||
`legacy fallback (no roadmap Progress table) must still classify complete via STATE.md. Got: ${result.situation}`);
|
||
});
|
||
|
||
test('legacy fallback: empty roadmap with current_phase < total_phases is NOT complete', () => {
|
||
const dir = track(makeProject({
|
||
state: state({ status: 'complete', total_phases: 5, current_phase: 3 }),
|
||
roadmap: true,
|
||
}));
|
||
const result = classifyProject(dir);
|
||
assert.notEqual(result.situation, 'complete',
|
||
`legacy fallback must still reject completion when current_phase < total_phases. Got: ${result.situation}`);
|
||
});
|
||
});
|
||
|
||
describe('smart-entry: stale_activity honors the template\'s "date — description" shape (#2570)', () => {
|
||
afterEach(removeAll);
|
||
|
||
// A fixed "now" far enough past 2026-06-08 that any real date there is well
|
||
// beyond IDLE_STALE_MS (72h). Injected so the test is deterministic and does
|
||
// not depend on the wall clock.
|
||
const FIXED_NOW = () => Date.parse('2026-08-01T00:00:00Z');
|
||
|
||
// msd-core's own STATE.md carries last_activity as "YYYY-MM-DD — <description>"
|
||
// (templates/state.md prescribes `Last activity: [YYYY-MM-DD] — [What happened]`
|
||
// for the body; the frontmatter mirrors it). Before the fix, parseActivityTimestamp
|
||
// ran Date.parse on the whole string → NaN → staleActivity failed OPEN to false,
|
||
// so the ONLY idle/staleness detector never fired on any project whose
|
||
// last_activity retained its description.
|
||
|
||
test('frontmatter last_activity with " — description" suffix is detected stale', () => {
|
||
const stateMd = [
|
||
'---',
|
||
'msd_state_version: 1.0',
|
||
'status: executing',
|
||
'last_activity: 2026-06-08 — Milestone 2 executed autonomously (all passed)',
|
||
'progress:',
|
||
' total_phases: 5',
|
||
' percent: 40',
|
||
'---',
|
||
'',
|
||
'# Project State',
|
||
'',
|
||
'Phase: 3',
|
||
'',
|
||
'**Status:** executing',
|
||
'',
|
||
].join('\n');
|
||
const dir = track(makeProject({ state: stateMd, roadmap: true }));
|
||
const signals = detectSignals(dir, FIXED_NOW);
|
||
assert.equal(
|
||
signals.stale_activity,
|
||
true,
|
||
'a 54-day-old last_activity carrying a description must read stale, not fail open to false',
|
||
);
|
||
});
|
||
|
||
test('body "Last activity: <date> — <desc>" fallback is detected stale', () => {
|
||
const stateMd = [
|
||
'# Project State',
|
||
'',
|
||
'## Current Position',
|
||
'',
|
||
'Phase: 1 of 1 (X)',
|
||
'Status: In progress',
|
||
'Last activity: 2026-06-08 — started the widget',
|
||
'',
|
||
].join('\n');
|
||
const dir = track(makeProject({ state: stateMd, roadmap: true }));
|
||
const signals = detectSignals(dir, FIXED_NOW);
|
||
assert.equal(signals.stale_activity, true, 'body-field fallback must also parse the leading date');
|
||
});
|
||
|
||
test('bare ISO date (control) still reads stale', () => {
|
||
const stateMd = [
|
||
'---',
|
||
'status: executing',
|
||
'last_activity: 2026-06-08',
|
||
'---',
|
||
'',
|
||
'# Project State',
|
||
'',
|
||
'Phase: 1',
|
||
'',
|
||
].join('\n');
|
||
const dir = track(makeProject({ state: stateMd, roadmap: true }));
|
||
const signals = detectSignals(dir, FIXED_NOW);
|
||
assert.equal(signals.stale_activity, true, 'bare-date parsing must be unchanged');
|
||
});
|
||
|
||
test('recent activity with a description is NOT stale (no false positive)', () => {
|
||
const stateMd = [
|
||
'---',
|
||
'status: executing',
|
||
'last_activity: 2026-07-31 — shipped a thing',
|
||
'---',
|
||
'',
|
||
'# Project State',
|
||
'',
|
||
'Phase: 1',
|
||
'',
|
||
].join('\n');
|
||
const dir = track(makeProject({ state: stateMd, roadmap: true }));
|
||
const signals = detectSignals(dir, FIXED_NOW);
|
||
assert.equal(
|
||
signals.stale_activity,
|
||
false,
|
||
'a next-day activity with a description must NOT be flagged stale',
|
||
);
|
||
});
|
||
|
||
// Boundary coverage for the fallback branch. NOTE: these are NOT fail-first
|
||
// regressions — a malformed or empty value returned null before the fix too.
|
||
// They pin the degrade-safely contract so a future change to the leading-date
|
||
// regex cannot start throwing, or start guessing, on unparseable input.
|
||
for (const [label, value] of [
|
||
['a malformed leading date', '2026-13-45 — nonsense month and day'],
|
||
['a non-date prefix', 'yesterday — did some work'],
|
||
['an empty value', ''],
|
||
['a whitespace-only value', ' '],
|
||
]) {
|
||
test(`${label} degrades to not-stale without throwing`, () => {
|
||
const stateMd = [
|
||
'---',
|
||
'status: executing',
|
||
`last_activity: ${value}`,
|
||
'---',
|
||
'',
|
||
'# Project State',
|
||
'',
|
||
'Phase: 1',
|
||
'',
|
||
].join('\n');
|
||
const dir = track(makeProject({ state: stateMd, roadmap: true }));
|
||
let signals;
|
||
assert.doesNotThrow(() => {
|
||
signals = detectSignals(dir, FIXED_NOW);
|
||
}, `${label} must not throw`);
|
||
// Unparseable reads as not-stale because staleActivity treats null as
|
||
// "not stale". That fail-open is pre-existing and out of scope for #2570
|
||
// (which is fenced to the description-suffix parse); asserted here so the
|
||
// behavior is recorded rather than silently assumed.
|
||
assert.equal(
|
||
signals.stale_activity,
|
||
false,
|
||
`${label} must degrade to not-stale, not throw or guess`,
|
||
);
|
||
});
|
||
}
|
||
|
||
// ADR-227: shape validation alone is not enough. Date.parse rolls an
|
||
// out-of-range DAY forward instead of rejecting it, so a shape-only guard
|
||
// propagates a different, wrong instant rather than failing safe. The
|
||
// pre-existing '2026-13-45' case above only exercises an invalid MONTH,
|
||
// which Date.parse happens to reject outright — it cannot catch this class.
|
||
//
|
||
// Only the two BARE cases are fail-first. On pre-fix code '2026-02-30'
|
||
// parses to 2026-03-02 and '2026-06-31' to 2026-07-01 — both read
|
||
// stale=true where the fix now reads false.
|
||
//
|
||
// The two suffixed cases are NOT fail-first: the trailing description
|
||
// already makes the pre-fix whole-string Date.parse return NaN, so
|
||
// stale_activity is false both before and after. They are kept because
|
||
// they pin the new calendar-validity behaviour for the suffix-carrying
|
||
// shape templates/state.md prescribes — but they do not demonstrate the
|
||
// regression, and should not be cited as if they did.
|
||
for (const [label, value] of [
|
||
['Feb 30 with a description', '2026-02-30 — fat-fingered the day'],
|
||
['Feb 30 bare', '2026-02-30'],
|
||
['Apr 31 with a description', '2026-04-31 — thirty days hath September'],
|
||
['Jun 31 bare', '2026-06-31'],
|
||
]) {
|
||
test(`an impossible calendar date (${label}) fails safe instead of rolling forward`, () => {
|
||
const stateMd = [
|
||
'---',
|
||
'status: executing',
|
||
`last_activity: ${value}`,
|
||
'---',
|
||
'',
|
||
'# Project State',
|
||
'',
|
||
'Phase: 1',
|
||
'',
|
||
].join('\n');
|
||
const dir = track(makeProject({ state: stateMd, roadmap: true }));
|
||
const signals = detectSignals(dir, FIXED_NOW);
|
||
assert.equal(
|
||
signals.stale_activity,
|
||
false,
|
||
`${label} must coerce to the safe default, not a rolled-forward instant`,
|
||
);
|
||
});
|
||
}
|
||
|
||
test('a real leap day still parses (the guard must not over-reject)', () => {
|
||
const stateMd = [
|
||
'---',
|
||
'status: executing',
|
||
'last_activity: 2024-02-29 — leap day is a real date',
|
||
'---',
|
||
'',
|
||
'# Project State',
|
||
'',
|
||
'Phase: 1',
|
||
'',
|
||
].join('\n');
|
||
const dir = track(makeProject({ state: stateMd, roadmap: true }));
|
||
const signals = detectSignals(dir, FIXED_NOW);
|
||
assert.equal(
|
||
signals.stale_activity,
|
||
true,
|
||
'a valid Feb 29 in a leap year must parse and read stale, not be rejected',
|
||
);
|
||
});
|
||
|
||
// RULESET.TESTS.boundary-coverage on IDLE_STALE_MS (72h). The comparison is a
|
||
// strict `now() - lastActivityMs > IDLE_STALE_MS`, so exactly-72h is NOT
|
||
// stale. Full ISO instants (not bare dates) are used deliberately: a bare
|
||
// date truncates to UTC midnight, which cannot express limit±1.
|
||
//
|
||
// NOT fail-first — these pass pre-fix too. They close the [24,95]h band the
|
||
// property tests skip, so an off-by-one in the threshold cannot land green.
|
||
for (const [label, value, expected] of [
|
||
['71h — one hour inside the window', '2026-07-29T01:00:00Z — 71h ago', false],
|
||
['72h — exactly at the limit (strict >)', '2026-07-29T00:00:00Z — 72h ago', false],
|
||
['73h — one hour past the limit', '2026-07-28T23:00:00Z — 73h ago', true],
|
||
]) {
|
||
test(`staleness boundary: ${label} -> stale=${expected}`, () => {
|
||
const stateMd = [
|
||
'---',
|
||
'status: executing',
|
||
`last_activity: ${value}`,
|
||
'---',
|
||
'',
|
||
'# Project State',
|
||
'',
|
||
'Phase: 1',
|
||
'',
|
||
].join('\n');
|
||
const dir = track(makeProject({ state: stateMd, roadmap: true }));
|
||
const signals = detectSignals(dir, FIXED_NOW);
|
||
assert.equal(
|
||
signals.stale_activity,
|
||
expected,
|
||
`${label} must read stale=${expected} against the 72h threshold`,
|
||
);
|
||
});
|
||
}
|
||
|
||
// Leniency guard. The calendar check must not narrow what already parsed:
|
||
// reading the leading token in preference to the whole string would DROP a
|
||
// trailing zone name and re-read the time as local, shifting the instant by
|
||
// the host's UTC offset. Pinned with a value whose verdict flips if that
|
||
// happens on a host east of UTC.
|
||
test('a trailing zone name is still honored, not dropped for the leading token', () => {
|
||
const stateMd = [
|
||
'---',
|
||
'status: executing',
|
||
'last_activity: 2026-07-28 23:30:00 GMT',
|
||
'---',
|
||
'',
|
||
'# Project State',
|
||
'',
|
||
'Phase: 1',
|
||
'',
|
||
].join('\n');
|
||
const dir = track(makeProject({ state: stateMd, roadmap: true }));
|
||
const signals = detectSignals(dir, FIXED_NOW);
|
||
// 2026-07-28T23:30:00Z is 72.5h before FIXED_NOW -> stale.
|
||
assert.equal(
|
||
signals.stale_activity,
|
||
true,
|
||
'GMT must be read as UTC; dropping it re-reads the time as local and moves the instant',
|
||
);
|
||
});
|
||
|
||
// #2571 B1 (fail-first): the SAME trailing zone but WITH a description suffix.
|
||
// The suffix makes the whole-string Date.parse fail (the #2570 premise), so
|
||
// control reaches the FALLBACK — the branch the test above never exercises,
|
||
// and the exact gap the round-4 review flagged. ISO_LEADING_RE's offset group
|
||
// captures only Z / +-HH:MM, so " GMT" is not in the leading token;
|
||
// reconstructing `${date}${time}` without it and letting Date.parse read the
|
||
// result as LOCAL time produces a wrong, host-dependent instant. The fix
|
||
// returns null (fails open to not-stale, ADR-227) instead of guessing.
|
||
//
|
||
// Fail-first and host-independent: on pre-fix code the reconstruction yields a
|
||
// still-~54-day-old local instant on ANY host (±14h can't cross 72h at that
|
||
// age) -> stale=true; the fix -> null -> false.
|
||
test('#2571: a named zone + description suffix fails open to not-stale, never a wrong local-time instant', () => {
|
||
const stateMd = [
|
||
'---',
|
||
'status: executing',
|
||
'last_activity: 2026-06-08T12:00:00 GMT — Milestone 2 executed autonomously',
|
||
'---',
|
||
'',
|
||
'# Project State',
|
||
'',
|
||
'Phase: 1',
|
||
'',
|
||
].join('\n');
|
||
const dir = track(makeProject({ state: stateMd, roadmap: true }));
|
||
const signals = detectSignals(dir, FIXED_NOW);
|
||
assert.equal(
|
||
signals.stale_activity,
|
||
false,
|
||
'an unpreservable named zone must fail open to not-stale (null), not reconstruct a ' +
|
||
'local-time instant whose verdict depends on the host UTC offset',
|
||
);
|
||
});
|
||
|
||
// #2571 (round-10, fail-first): a leading real date followed by a
|
||
// WHITESPACE/COLON separator and an ordinary description — no zone designator.
|
||
// The pre-fix fallback guard ("/^\\s*[A-Za-z]/", return null on any letter)
|
||
// could not tell a named zone from a plain word, so it failed open on exactly
|
||
// these and silently re-opened #2570 for hand-edited STATE.md that omits the
|
||
// template em dash. The narrowed guard reconstructs from the leading date;
|
||
// only a zone-shaped remainder (short all-caps run) still fails open.
|
||
//
|
||
// Fail-first and host-independent: `2026-06-08` is ~54 days before FIXED_NOW,
|
||
// so the reconstructed UTC-midnight instant reads stale on any host; the
|
||
// pre-fix guard returns null -> not-stale, inverting the verdict.
|
||
// The last two lead with an all-caps tech acronym on a BARE date: a zone
|
||
// qualifies a clock time, so a date with no time-of-day carries no zone hazard
|
||
// and must reconstruct. A time-agnostic all-caps guard would fail open on these.
|
||
for (const value of [
|
||
'last_activity: 2026-06-08 caught up on backlog', // space + lowercase
|
||
'last_activity: 2026-06-08\tfixed the login bug', // tab + lowercase
|
||
'last_activity: 2026-06-08 Milestone two executed', // space + Capitalised word
|
||
'last_activity: 2026-06-08: reviewed the PR queue', // colon separator
|
||
'last_activity: 2026-06-08 CI green, shipped it', // bare date + acronym lead
|
||
'last_activity: 2026-06-08 API refactor complete', // bare date + acronym lead
|
||
]) {
|
||
test(`#2571: a plain description after "${value.slice(29, 45)}…" reads stale, not fail-open`, () => {
|
||
const stateMd = ['---', 'status: executing', value, '---', '', '# Project State', '', 'Phase: 1', ''].join(
|
||
'\n',
|
||
);
|
||
const dir = track(makeProject({ state: stateMd, roadmap: true }));
|
||
const signals = detectSignals(dir, FIXED_NOW);
|
||
assert.equal(
|
||
signals.stale_activity,
|
||
true,
|
||
'a leading real date with a non-zone description suffix must reconstruct and read ' +
|
||
'stale, not fail open the way the "any letter" guard did',
|
||
);
|
||
});
|
||
}
|
||
|
||
// CONTRIBUTING.md QA Matrix: "Mixed CRLF/LF newlines" for frontmatter parsing
|
||
// changes. No live defect — the fallback branch trims before matching — but
|
||
// the standard asks for the fixture, and this pins it.
|
||
test('a CRLF-terminated STATE.md parses the suffixed date identically', () => {
|
||
const stateMd = [
|
||
'---',
|
||
'status: executing',
|
||
'last_activity: 2026-06-08 — started the widget',
|
||
'---',
|
||
'',
|
||
'# Project State',
|
||
'',
|
||
'Phase: 1',
|
||
'',
|
||
].join('\r\n');
|
||
const dir = track(makeProject({ state: stateMd, roadmap: true }));
|
||
const signals = detectSignals(dir, FIXED_NOW);
|
||
assert.equal(
|
||
signals.stale_activity,
|
||
true,
|
||
'CRLF line endings must not change the parsed instant',
|
||
);
|
||
});
|
||
|
||
// #2570 × #3099 composition: a suffixed value whose LEADING DATE parses must
|
||
// take the stale path AND must NOT emit LAST_ACTIVITY_UNPARSEABLE. Guards
|
||
// against two independent staleness signals firing on one field — #3099's
|
||
// diagnostic is for genuinely unusable values, and #2570 makes this shape
|
||
// usable, so the diagnostic must stay silent here.
|
||
test('suffixed-but-parseable last_activity is stale and emits NO diagnostic (composes with #3099)', () => {
|
||
const {
|
||
_resetUnusableInputWarningsForTests,
|
||
_unusableInputEmissionCountForTests,
|
||
} = require('../msd-core/bin/lib/unusable-input.cjs');
|
||
_resetUnusableInputWarningsForTests();
|
||
const stateMd = [
|
||
'---',
|
||
'status: executing',
|
||
'last_activity: 2026-06-08 — Milestone 2 executed autonomously',
|
||
'---',
|
||
'',
|
||
'# Project State',
|
||
'',
|
||
'Phase: 1',
|
||
'',
|
||
].join('\n');
|
||
const dir = track(makeProject({ state: stateMd, roadmap: true }));
|
||
const signals = detectSignals(dir, FIXED_NOW);
|
||
assert.equal(signals.stale_activity, true,
|
||
'a suffixed value whose leading date parses must read stale');
|
||
assert.equal(_unusableInputEmissionCountForTests(), 0,
|
||
'a now-parseable value must NOT emit LAST_ACTIVITY_UNPARSEABLE (no double staleness signal)');
|
||
});
|
||
});
|
||
|
||
// ─── #2573: STATE.md commit-age freshness signal ─────────────────────────────
|
||
|
||
describe('detectSignals — state_head commit-age freshness (#2573)', () => {
|
||
const { runGit } = require('./helpers/process-seam.cjs');
|
||
|
||
const dirs = [];
|
||
const track = (d) => { dirs.push(d); return d; };
|
||
afterEach(() => { while (dirs.length) cleanup(dirs.pop()); });
|
||
|
||
function gitProject(stateHead) {
|
||
const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'msd-2573-se-'));
|
||
fs.mkdirSync(path.join(dir, '.planning'), { recursive: true });
|
||
runGit(['init', '-q'], { cwd: dir });
|
||
runGit(['config', 'user.email', 't@t.com'], { cwd: dir });
|
||
runGit(['config', 'user.name', 'T'], { cwd: dir });
|
||
runGit(['config', 'commit.gpgsign', 'false'], { cwd: dir });
|
||
fs.writeFileSync(path.join(dir, 'seed.txt'), 'seed\n');
|
||
runGit(['add', '-A'], { cwd: dir });
|
||
runGit(['commit', '-q', '-m', 'seed'], { cwd: dir });
|
||
const base = runGit(['rev-parse', 'HEAD'], { cwd: dir }).stdout.trim();
|
||
|
||
fs.writeFileSync(
|
||
path.join(dir, '.planning', 'STATE.md'),
|
||
[
|
||
'---',
|
||
'status: executing',
|
||
...(stateHead === null ? [] : [`state_head: ${stateHead === 'BASE' ? base : stateHead}`]),
|
||
'---',
|
||
'',
|
||
'# Project State',
|
||
'',
|
||
'Phase: 1',
|
||
'',
|
||
].join('\n'),
|
||
);
|
||
return { dir: track(dir), base };
|
||
}
|
||
|
||
function advance(dir, n) {
|
||
for (let i = 0; i < n; i++) {
|
||
fs.writeFileSync(path.join(dir, `c${i}.txt`), `${i}\n`);
|
||
runGit(['add', '-A'], { cwd: dir });
|
||
runGit(['commit', '-q', '-m', `c${i}`], { cwd: dir });
|
||
}
|
||
}
|
||
|
||
test('state_head at HEAD → commits_behind 0, commit_stale false (known fresh)', () => {
|
||
const { dir } = gitProject('BASE');
|
||
const s = detectSignals(dir);
|
||
assert.strictEqual(s.state_commits_behind, 0);
|
||
assert.strictEqual(s.state_commit_stale, false);
|
||
});
|
||
|
||
test('state_head N commits back → commits_behind N', () => {
|
||
const { dir } = gitProject('BASE');
|
||
advance(dir, 3);
|
||
const s = detectSignals(dir);
|
||
assert.strictEqual(s.state_commits_behind, 3,
|
||
'commits_behind must count commits between state_head and HEAD');
|
||
assert.strictEqual(s.state_commit_stale, true);
|
||
});
|
||
|
||
test('missing state_head → tri-state null ("we don\'t know"), NOT false', () => {
|
||
// Mirrors graphify's shipped commit_stale contract (src/graphify.cts:446):
|
||
// null = unknown, distinct from false = known fresh. Collapsing unknown to
|
||
// false would assert freshness the engine cannot actually vouch for.
|
||
const { dir } = gitProject(null);
|
||
const s = detectSignals(dir);
|
||
assert.strictEqual(s.state_commits_behind, null);
|
||
assert.strictEqual(s.state_commit_stale, null);
|
||
});
|
||
|
||
test('malformed / unreachable state_head → null, never throws', () => {
|
||
for (const bad of ['not-a-sha', 'zzzz', 'deadbeefdeadbeefdeadbeefdeadbeefdeadbeef']) {
|
||
const { dir } = gitProject(bad);
|
||
let s;
|
||
assert.doesNotThrow(() => { s = detectSignals(dir); }, `${bad} must not throw`);
|
||
assert.strictEqual(s.state_commits_behind, null, `${bad} → null`);
|
||
assert.strictEqual(s.state_commit_stale, null, `${bad} → null`);
|
||
}
|
||
});
|
||
|
||
test('non-git project → null (no signal), never throws', () => {
|
||
const dir = track(fs.mkdtempSync(path.join(os.tmpdir(), 'msd-2573-nogit-')));
|
||
fs.mkdirSync(path.join(dir, '.planning'), { recursive: true });
|
||
fs.writeFileSync(
|
||
path.join(dir, '.planning', 'STATE.md'),
|
||
['---', 'status: executing', 'state_head: abc1234', '---', '', '# Project State', ''].join('\n'),
|
||
);
|
||
let s;
|
||
assert.doesNotThrow(() => { s = detectSignals(dir); });
|
||
assert.strictEqual(s.state_commit_stale, null);
|
||
});
|
||
|
||
// #2573 × #3099 composition: the commit-age freshness signal reads `state_head`
|
||
// while the LAST_ACTIVITY_UNPARSEABLE diagnostic reads `last_activity` — two
|
||
// DIFFERENT fields. A STATE.md carrying both an unparseable last_activity AND a
|
||
// valid state_head must resolve each independently: the diagnostic fires for
|
||
// last_activity, and the freshness signal still reads state_head. Neither
|
||
// shadows the other (they are not "two staleness signals on one field").
|
||
test('unparseable last_activity + valid state_head compose: diagnostic fires AND freshness reads independently (#3099)', () => {
|
||
const {
|
||
_resetUnusableInputWarningsForTests,
|
||
_unusableInputEmissionCountForTests,
|
||
} = require('../msd-core/bin/lib/unusable-input.cjs');
|
||
_resetUnusableInputWarningsForTests();
|
||
const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'msd-2573-compose-'));
|
||
fs.mkdirSync(path.join(dir, '.planning'), { recursive: true });
|
||
runGit(['init', '-q'], { cwd: dir });
|
||
runGit(['config', 'user.email', 't@t.com'], { cwd: dir });
|
||
runGit(['config', 'user.name', 'T'], { cwd: dir });
|
||
runGit(['config', 'commit.gpgsign', 'false'], { cwd: dir });
|
||
fs.writeFileSync(path.join(dir, 'seed.txt'), 'seed\n');
|
||
runGit(['add', '-A'], { cwd: dir });
|
||
runGit(['commit', '-q', '-m', 'seed'], { cwd: dir });
|
||
const base = runGit(['rev-parse', 'HEAD'], { cwd: dir }).stdout.trim();
|
||
track(dir);
|
||
fs.writeFileSync(
|
||
path.join(dir, '.planning', 'STATE.md'),
|
||
[
|
||
'---',
|
||
'status: executing',
|
||
'last_activity: not-a-real-date at all',
|
||
`state_head: ${base}`,
|
||
'---',
|
||
'',
|
||
'# Project State',
|
||
'',
|
||
'Phase: 1',
|
||
'',
|
||
].join('\n'),
|
||
);
|
||
const s = detectSignals(dir);
|
||
// last_activity is unusable → its diagnostic fires (its own field), exactly once.
|
||
assert.strictEqual(_unusableInputEmissionCountForTests(), 1,
|
||
'unparseable last_activity must emit exactly one LAST_ACTIVITY_UNPARSEABLE — the freshness path adds none');
|
||
// state_head still resolves independently → fresh (0 commits behind HEAD).
|
||
assert.strictEqual(s.state_commits_behind, 0,
|
||
'state_head freshness must resolve independently of the last_activity diagnostic');
|
||
assert.strictEqual(s.state_commit_stale, false);
|
||
});
|
||
});
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// #3099: unusable last_activity emits a diagnostic (ADR-1411 amendment:
|
||
// corrupt is not absent — the fallback stays, the silence is the defect)
|
||
// ---------------------------------------------------------------------------
|
||
|
||
describe('#3099: unusable last_activity emits a diagnostic', () => {
|
||
const {
|
||
_resetUnusableInputWarningsForTests,
|
||
_unusableInputEmissionCountForTests,
|
||
} = require('../msd-core/bin/lib/unusable-input.cjs');
|
||
|
||
function makeStateWithActivity(activity) {
|
||
return [
|
||
'---',
|
||
'status: executing',
|
||
`last_activity: ${activity}`,
|
||
'---',
|
||
'',
|
||
'# Project State',
|
||
'',
|
||
'Phase: 1',
|
||
'',
|
||
].join('\n');
|
||
}
|
||
|
||
test('unusable last_activity still resolves stale_activity: false (fallback unchanged)', () => {
|
||
_resetUnusableInputWarningsForTests();
|
||
const dir = track(makeProject({
|
||
state: makeStateWithActivity('yesterday - did some work'),
|
||
}));
|
||
const signals = detectSignals(dir);
|
||
assert.equal(signals.stale_activity, false,
|
||
'unusable last_activity must still resolve stale_activity: false (continuity is correct)');
|
||
});
|
||
|
||
test('unusable last_activity emits LAST_ACTIVITY_UNPARSEABLE diagnostic', () => {
|
||
_resetUnusableInputWarningsForTests();
|
||
const dir = track(makeProject({
|
||
state: makeStateWithActivity('not-a-date-at-all'),
|
||
}));
|
||
detectSignals(dir);
|
||
assert.equal(_unusableInputEmissionCountForTests(), 1,
|
||
'unusable last_activity must emit exactly one diagnostic');
|
||
});
|
||
|
||
test('absent last_activity emits nothing (distinguishable from unusable)', () => {
|
||
_resetUnusableInputWarningsForTests();
|
||
const dir = track(makeProject({
|
||
state: [
|
||
'---',
|
||
'status: executing',
|
||
'---',
|
||
'',
|
||
'# Project State',
|
||
'',
|
||
'Phase: 1',
|
||
'',
|
||
].join('\n'),
|
||
}));
|
||
detectSignals(dir);
|
||
assert.equal(_unusableInputEmissionCountForTests(), 0,
|
||
'absent last_activity must NOT emit a diagnostic (it is genuinely absent, not corrupt)');
|
||
});
|
||
|
||
test('well-formed last_activity emits nothing', () => {
|
||
_resetUnusableInputWarningsForTests();
|
||
const dir = track(makeProject({
|
||
state: makeStateWithActivity('2026-06-13T12:00:00Z'),
|
||
}));
|
||
detectSignals(dir);
|
||
assert.equal(_unusableInputEmissionCountForTests(), 0,
|
||
'well-formed last_activity must NOT emit a diagnostic');
|
||
});
|
||
|
||
test('unusable last_activity does not re-emit on second call (dedup)', () => {
|
||
_resetUnusableInputWarningsForTests();
|
||
const dir = track(makeProject({
|
||
state: makeStateWithActivity('gibberish'),
|
||
}));
|
||
detectSignals(dir);
|
||
detectSignals(dir);
|
||
assert.equal(_unusableInputEmissionCountForTests(), 1,
|
||
'dedup: second call on the same source must not re-emit');
|
||
});
|
||
});
|