sdd-agent-platform 0.4.2 → 0.5.1

package/node_modules/@sdd-agent-platform/core/src/ai-tools.test.ts

@@ -1,186 +1,239 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-
-import { doctor } from './doctor/doctor.js';
-import { initProject } from './config/init-project.js';
-import { withManagedHash } from './test-support/fixtures.js';
-import { applyAiToolEntries, checkAiToolEntryDrift, projectAiToolEntries } from './ai-tools.js';
-
-import { importRuntimeSkillCapability } from './router/runtime-import.js';
-import { inspectSkillCapability } from './router/runtime-inspection.js';
-test('AI entry drift check distinguishes managed drift from user modifications', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-ai-drift-'));
-  try {
-    await initProject(root);
-    const skillPath = path.join(root, '.claude', 'skills', 'sdd', 'SKILL.md');
-    const original = await readFile(skillPath, 'utf8');
-    const oldManagedTemplate = withManagedHash(original.replace('This skill is the manual `/sdd` root intent router; do not treat this generated file as the workflow brain.', 'Run the SDD workflow entrypoint for this repository.'));
-    await writeFile(skillPath, oldManagedTemplate, 'utf8');
-
-    const drift = await checkAiToolEntryDrift(root);
-    const driftedEntry = drift[0].entries.find((entry) => entry.id === 'sdd');
-    assert.equal(driftedEntry?.status, 'drifted');
-    assert.equal(driftedEntry?.driftStatus, 'drifted');
-    assert.equal(driftedEntry?.manifest.path, '.claude/skills/sdd/SKILL.md');
-    assert.equal(driftedEntry?.manifest.artifactId, 'sdd');
-    assert.equal(driftedEntry?.manifest.ownership, 'sdd-managed');
-    assert.equal(driftedEntry?.manifest.sourceContract, 'sdd-ai-entry-v1');
-
-    const update = await applyAiToolEntries(root);
-    assert.equal(update[0].entries.some((entry) => entry.id === 'sdd' && entry.status === 'updated'), true);
-    const clean = await checkAiToolEntryDrift(root);
-    assert.equal(clean[0].entries.every((entry) => entry.status === 'unchanged'), true);
-
-    await writeFile(skillPath, `${await readFile(skillPath, 'utf8')}\nmanual drift\n`, 'utf8');
-    const userModified = await checkAiToolEntryDrift(root);
-    assert.equal(userModified[0].entries.some((entry) => entry.id === 'sdd' && entry.status === 'user-modified'), true);
-    const skippedUpdate = await applyAiToolEntries(root);
-    assert.equal(skippedUpdate[0].entries.some((entry) => entry.id === 'sdd' && entry.status === 'user-modified'), true);
-    assert.match(await readFile(skillPath, 'utf8'), /manual drift/);
-    const doctorReport = await doctor(root, { latestOnly: true });
-    assert.equal(doctorReport.checks.some((check) => check.check === 'ai_entry_sdd' && check.level === 'FAIL' && /will not overwrite user-modified/.test(check.action ?? '')), true);
-
-    const forcedUpdate = await applyAiToolEntries(root, { force: true });
-    assert.equal(forcedUpdate[0].entries.some((entry) => entry.id === 'sdd' && entry.status === 'updated'), true);
-    assert.doesNotMatch(await readFile(skillPath, 'utf8'), /manual drift/);
-    const forcedClean = await checkAiToolEntryDrift(root);
-    assert.equal(forcedClean[0].entries.every((entry) => entry.status === 'unchanged'), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('AI entry drift check includes managed entry version', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-ai-version-drift-'));
-  try {
-    await initProject(root);
-    const skillPath = path.join(root, '.claude', 'skills', 'sdd', 'SKILL.md');
-    const original = await readFile(skillPath, 'utf8');
-    await writeFile(skillPath, original.replace('sdd_version: "0.3.0"', 'sdd_version: "0.2.0"'), 'utf8');
-
-    const drift = await checkAiToolEntryDrift(root);
-    assert.equal(drift[0].entries.some((entry) => entry.id === 'sdd' && entry.status === 'drifted'), true);
-
-    const update = await applyAiToolEntries(root);
-    assert.equal(update[0].entries.some((entry) => entry.id === 'sdd' && entry.status === 'updated'), true);
-    assert.match(await readFile(skillPath, 'utf8'), /sdd_version: "0\.3\.0"/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('AI entry projection refuses foreign files', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-ai-foreign-'));
-  try {
-    await mkdir(path.join(root, '.claude', 'skills', 'sdd'), { recursive: true });
-    await writeFile(path.join(root, '.claude', 'skills', 'sdd', 'SKILL.md'), 'user-owned skill', 'utf8');
-    const init = await initProject(root);
-    const foreign = init.aiTools[0].entries.find((entry) => entry.id === 'sdd');
-
-    assert.equal(foreign?.status, 'foreign');
-    assert.equal(await readFile(path.join(root, '.claude', 'skills', 'sdd', 'SKILL.md'), 'utf8'), 'user-owned skill');
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('AI entry update removes obsolete managed entries', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-ai-obsolete-'));
-  try {
-    await initProject(root);
-    const obsoleteVerifyPath = path.join(root, '.claude', 'commands', 'sdd', 'verify.md');
-    const obsoleteVerifyContent = withManagedHash(`---
-sdd_managed: true
-sdd_contract: sdd-ai-entry-v1
-sdd_version: "0.3.0"
-sdd_tool: claude-code
-sdd_artifact_kind: command
-sdd_artifact_id: sdd-verify
-sdd_source: sdd-agent-platform
-sdd_hash: sha256:0000000000000000000000000000000000000000000000000000000000000000
----
-
-Legacy verify command.
-`);
-    await writeFile(obsoleteVerifyPath, obsoleteVerifyContent, 'utf8');
-    const obsoleteRootPath = path.join(root, '.claude', 'commands', 'sdd.md');
-    const obsoleteRootContent = withManagedHash(`---
-sdd_managed: true
-sdd_contract: sdd-ai-entry-v1
-sdd_version: "0.3.0"
-sdd_tool: claude-code
-sdd_artifact_kind: command
-sdd_artifact_id: sdd-root
-sdd_source: sdd-agent-platform
-sdd_hash: sha256:0000000000000000000000000000000000000000000000000000000000000000
----
-
-Legacy root command.
-`);
-    await writeFile(obsoleteRootPath, obsoleteRootContent, 'utf8');
-
-    const drift = await checkAiToolEntryDrift(root);
-    assert.equal(drift[0].entries.some((entry) => entry.id === 'sdd-verify' && entry.status === 'obsolete'), true);
-    assert.equal(drift[0].entries.some((entry) => entry.id === 'sdd-root' && entry.status === 'obsolete'), true);
-
-    const update = await applyAiToolEntries(root);
-    assert.equal(update[0].entries.some((entry) => entry.id === 'sdd-verify' && entry.status === 'removed'), true);
-    assert.equal(update[0].entries.some((entry) => entry.id === 'sdd-root' && entry.status === 'removed'), true);
-    await assert.rejects(readFile(obsoleteVerifyPath, 'utf8'), /ENOENT/);
-    await assert.rejects(readFile(obsoleteRootPath, 'utf8'), /ENOENT/);
-
-    const clean = await checkAiToolEntryDrift(root);
-    assert.equal(clean[0].entries.every((entry) => entry.status === 'unchanged'), true);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('init bootstraps skill import and update re-imports with dedupe', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'sdd-skill-import-trigger-'));
-  try {
-    const init = await initProject(root, {
-      skillImports: [{
-        capabilityId: 'user.skill.ui_ux_pro_max',
-        source: 'user_global',
-        sourceRef: 'C:\\Users\\inshn\\.claude\\skills\\ui-ux-pro-max\\SKILL.md',
-        name: 'UI UX Pro Max',
-        domains: ['ui_ux', 'frontend'],
-        stages: ['spec', 'plan', 'test'],
-        allowedEvidenceTypes: ['candidate_evidence', 'design_context'],
-        attribution: 'user-global Claude Code skill'
-      }]
-    });
-
-    assert.equal(init.skillImports[0]?.status, 'created');
-    assert.equal(init.skillImports[0]?.written, true);
-    assert.equal((await inspectSkillCapability(root, 'user.skill.ui_ux_pro_max'))?.source, 'user_global');
-
-    const unchanged = await importRuntimeSkillCapability(root, {
-      capabilityId: 'user.skill.ui_ux_pro_max',
-      source: 'user_global',
-      sourceRef: 'C:\\Users\\inshn\\.claude\\skills\\ui-ux-pro-max\\SKILL.md',
-      name: 'UI UX Pro Max',
-      domains: ['ui_ux', 'frontend'],
-      stages: ['spec', 'plan', 'test'],
-      allowedEvidenceTypes: ['candidate_evidence', 'design_context'],
-      attribution: 'user-global Claude Code skill'
-    });
-
-    assert.equal(unchanged.status, 'unchanged');
-    assert.equal(unchanged.written, false);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('AI projection includes sdd update command for skill re-import path', () => {
-  const updateEntry = projectAiToolEntries().find((entry) => entry.id === 'sdd-update');
-
-  assert.ok(updateEntry);
-  assert.equal(updateEntry.relativePath, '.claude/commands/sdd/update.md');
-  assert.match(updateEntry.content, /sdd update --import-skill <capability_id>/);
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+import { doctor } from './doctor/doctor.js';
+import { initProject } from './config/init-project.js';
+import { withManagedHash } from './test-support/fixtures.js';
+import { applyAiToolEntries, checkAiToolEntryDrift, projectAiToolEntries } from './ai-tools.js';
+
+import { importRuntimeSkillCapability } from './router/runtime-import.js';
+import { inspectSkillCapability } from './router/runtime-inspection.js';
+test('AI entry drift check distinguishes managed drift from user modifications', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-ai-drift-'));
+  try {
+    await initProject(root);
+    const skillPath = path.join(root, '.claude', 'skills', 'sdd', 'SKILL.md');
+    const original = await readFile(skillPath, 'utf8');
+    const oldManagedTemplate = withManagedHash(original.replace('This skill is the manual `/sdd` root intent router; do not treat this generated file as the workflow brain.', 'Run the SDD workflow entrypoint for this repository.'));
+    await writeFile(skillPath, oldManagedTemplate, 'utf8');
+
+    const drift = await checkAiToolEntryDrift(root);
+    const driftedEntry = drift[0].entries.find((entry) => entry.id === 'sdd');
+    assert.equal(driftedEntry?.status, 'drifted');
+    assert.equal(driftedEntry?.driftStatus, 'drifted');
+    assert.equal(driftedEntry?.manifest.path, '.claude/skills/sdd/SKILL.md');
+    assert.equal(driftedEntry?.manifest.artifactId, 'sdd');
+    assert.equal(driftedEntry?.manifest.ownership, 'sdd-managed');
+    assert.equal(driftedEntry?.manifest.sourceContract, 'sdd-ai-entry-v1');
+
+    const update = await applyAiToolEntries(root);
+    assert.equal(update[0].entries.some((entry) => entry.id === 'sdd' && entry.status === 'updated'), true);
+    const clean = await checkAiToolEntryDrift(root);
+    assert.equal(clean[0].entries.every((entry) => entry.status === 'unchanged'), true);
+
+    await writeFile(skillPath, `${await readFile(skillPath, 'utf8')}\nmanual drift\n`, 'utf8');
+    const userModified = await checkAiToolEntryDrift(root);
+    assert.equal(userModified[0].entries.some((entry) => entry.id === 'sdd' && entry.status === 'user-modified'), true);
+    const skippedUpdate = await applyAiToolEntries(root);
+    assert.equal(skippedUpdate[0].entries.some((entry) => entry.id === 'sdd' && entry.status === 'user-modified'), true);
+    assert.match(await readFile(skillPath, 'utf8'), /manual drift/);
+    const doctorReport = await doctor(root, { latestOnly: true });
+    assert.equal(doctorReport.checks.some((check) => check.check === 'ai_entry_sdd' && check.level === 'FAIL' && /will not overwrite user-modified/.test(check.action ?? '')), true);
+
+    const forcedUpdate = await applyAiToolEntries(root, { force: true });
+    assert.equal(forcedUpdate[0].entries.some((entry) => entry.id === 'sdd' && entry.status === 'updated'), true);
+    assert.doesNotMatch(await readFile(skillPath, 'utf8'), /manual drift/);
+    const forcedClean = await checkAiToolEntryDrift(root);
+    assert.equal(forcedClean[0].entries.every((entry) => entry.status === 'unchanged'), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('AI entry drift check includes managed entry version', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-ai-version-drift-'));
+  try {
+    await initProject(root);
+    const skillPath = path.join(root, '.claude', 'skills', 'sdd', 'SKILL.md');
+    const original = await readFile(skillPath, 'utf8');
+    await writeFile(skillPath, original.replace('sdd_version: "0.3.0"', 'sdd_version: "0.2.0"'), 'utf8');
+
+    const drift = await checkAiToolEntryDrift(root);
+    assert.equal(drift[0].entries.some((entry) => entry.id === 'sdd' && entry.status === 'drifted'), true);
+
+    const update = await applyAiToolEntries(root);
+    assert.equal(update[0].entries.some((entry) => entry.id === 'sdd' && entry.status === 'updated'), true);
+    assert.match(await readFile(skillPath, 'utf8'), /sdd_version: "0\.3\.0"/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('AI entry projection refuses foreign files', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-ai-foreign-'));
+  try {
+    await mkdir(path.join(root, '.claude', 'skills', 'sdd'), { recursive: true });
+    await writeFile(path.join(root, '.claude', 'skills', 'sdd', 'SKILL.md'), 'user-owned skill', 'utf8');
+    const init = await initProject(root);
+    const foreign = init.aiTools[0].entries.find((entry) => entry.id === 'sdd');
+
+    assert.equal(foreign?.status, 'foreign');
+    assert.equal(await readFile(path.join(root, '.claude', 'skills', 'sdd', 'SKILL.md'), 'utf8'), 'user-owned skill');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('AI entry update removes obsolete managed entries', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-ai-obsolete-'));
+  try {
+    await initProject(root);
+    const obsoleteVerifyPath = path.join(root, '.claude', 'commands', 'sdd', 'verify.md');
+    const obsoleteVerifyContent = withManagedHash(`---
+sdd_managed: true
+sdd_contract: sdd-ai-entry-v1
+sdd_version: "0.3.0"
+sdd_tool: claude-code
+sdd_artifact_kind: command
+sdd_artifact_id: sdd-verify
+sdd_source: sdd-agent-platform
+sdd_hash: sha256:0000000000000000000000000000000000000000000000000000000000000000
+---
+
+Legacy verify command.
+`);
+    await writeFile(obsoleteVerifyPath, obsoleteVerifyContent, 'utf8');
+    const obsoleteRootPath = path.join(root, '.claude', 'commands', 'sdd.md');
+    const obsoleteRootContent = withManagedHash(`---
+sdd_managed: true
+sdd_contract: sdd-ai-entry-v1
+sdd_version: "0.3.0"
+sdd_tool: claude-code
+sdd_artifact_kind: command
+sdd_artifact_id: sdd-root
+sdd_source: sdd-agent-platform
+sdd_hash: sha256:0000000000000000000000000000000000000000000000000000000000000000
+---
+
+Legacy root command.
+`);
+    await writeFile(obsoleteRootPath, obsoleteRootContent, 'utf8');
+
+    const drift = await checkAiToolEntryDrift(root);
+    assert.equal(drift[0].entries.some((entry) => entry.id === 'sdd-verify' && entry.status === 'obsolete'), true);
+    assert.equal(drift[0].entries.some((entry) => entry.id === 'sdd-root' && entry.status === 'obsolete'), true);
+
+    const update = await applyAiToolEntries(root);
+    assert.equal(update[0].entries.some((entry) => entry.id === 'sdd-verify' && entry.status === 'removed'), true);
+    assert.equal(update[0].entries.some((entry) => entry.id === 'sdd-root' && entry.status === 'removed'), true);
+    await assert.rejects(readFile(obsoleteVerifyPath, 'utf8'), /ENOENT/);
+    await assert.rejects(readFile(obsoleteRootPath, 'utf8'), /ENOENT/);
+
+    const clean = await checkAiToolEntryDrift(root);
+    assert.equal(clean[0].entries.every((entry) => entry.status === 'unchanged'), true);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('init bootstraps skill import and update re-imports with dedupe', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-skill-import-trigger-'));
+  try {
+    const init = await initProject(root, {
+      skillImports: [{
+        capabilityId: 'user.skill.ui_ux_pro_max',
+        source: 'user_global',
+        sourceRef: 'C:\\Users\\inshn\\.claude\\skills\\ui-ux-pro-max\\SKILL.md',
+        name: 'UI UX Pro Max',
+        domains: ['ui_ux', 'frontend'],
+        stages: ['spec', 'plan', 'execute'],
+        allowedEvidenceTypes: ['candidate_evidence', 'design_context'],
+        attribution: 'user-global Claude Code skill'
+      }]
+    });
+
+    assert.equal(init.skillImports[0]?.status, 'created');
+    assert.equal(init.skillImports[0]?.written, true);
+    assert.equal((await inspectSkillCapability(root, 'user.skill.ui_ux_pro_max'))?.source, 'user_global');
+
+    const unchanged = await importRuntimeSkillCapability(root, {
+      capabilityId: 'user.skill.ui_ux_pro_max',
+      source: 'user_global',
+      sourceRef: 'C:\\Users\\inshn\\.claude\\skills\\ui-ux-pro-max\\SKILL.md',
+      name: 'UI UX Pro Max',
+      domains: ['ui_ux', 'frontend'],
+      stages: ['spec', 'plan', 'execute'],
+      allowedEvidenceTypes: ['candidate_evidence', 'design_context'],
+      attribution: 'user-global Claude Code skill'
+    });
+
+    assert.equal(unchanged.status, 'unchanged');
+    assert.equal(unchanged.written, false);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('AI projection includes sdd update command for skill re-import path', () => {
+  const updateEntry = projectAiToolEntries().find((entry) => entry.id === 'sdd-update');
+
+  assert.ok(updateEntry);
+  assert.equal(updateEntry.relativePath, '.claude/commands/sdd/update.md');
+  assert.match(updateEntry.content, /sdd update --import-skill <capability_id>/);
+});
+
+test('AI projection exposes execute as public lifecycle command', () => {
+  const entries = projectAiToolEntries();
+  const rootEntry = entries.find((entry) => entry.id === 'sdd');
+  const planEntry = entries.find((entry) => entry.id === 'sdd-plan');
+  const executeEntry = entries.find((entry) => entry.id === 'sdd-execute');
+  const tasksEntry = entries.find((entry) => entry.id === 'sdd-tasks');
+  const doEntry = entries.find((entry) => entry.id === 'sdd-do');
+  const testEntry = entries.find((entry) => entry.id === 'sdd-test');
+
+  assert.ok(rootEntry);
+  assert.ok(planEntry);
+  assert.ok(executeEntry);
+  assert.equal(executeEntry.relativePath, '.claude/commands/sdd/execute.md');
+  assert.match(executeEntry.content, /public \/sdd:execute stage/);
+  assert.match(executeEntry.content, /materializes TaskUnitProjection\/ExecutionLaneProjection\/TaskDependencyGraphProjection through `sdd execute --branch <branch> --json`/);
+  assert.match(executeEntry.content, /reject missing\/stale tasks handoff/);
+  assert.match(rootEntry.content, /\/sdd:spec -> \/sdd:plan -> \/sdd:tasks -> \/sdd:execute -> \/sdd:ship/);
+  assert.equal(rootEntry.content.includes('/sdd:execute -> /sdd:ship'), true);
+  assert.match(planEntry.content, /plan-review-agent/);
+  assert.match(planEntry.content, /Side logs are never runtime primary truth/);
+  assert.match(planEntry.content, /blocking design decisions/);
+  assert.match(tasksEntry?.content ?? '', /AI-ready Implementation Tickets/);
+  assert.match(tasksEntry?.content ?? '', /task-slicer/);
+  assert.match(tasksEntry?.content ?? '', /task-review-agent/);
+  assert.match(tasksEntry?.content ?? '', /TOO_THIN_FOR_EXECUTE/);
+  assert.match(tasksEntry?.content ?? '', /missing failure routes/);
+  assert.match(tasksEntry?.content ?? '', /internal execution sequence/);
+  assert.match(tasksEntry?.content ?? '', /one-to-one validation task/);
+  assert.match(tasksEntry?.content ?? '', /Do not mechanically split by file type/);
+  assert.match(tasksEntry?.content ?? '', /many-to-one validation/);
+  assert.doesNotMatch(tasksEntry?.content ?? '', /typed execution topology contract/);
+  assert.doesNotMatch(executeEntry.content, /requiredCommands\[\]/);
+  assert.equal(doEntry, undefined);
+  assert.equal(testEntry, undefined);
+});
+
+test('AI projection routes spec command through spec-manager handoff', () => {
+  const specEntry = projectAiToolEntries().find((entry) => entry.id === 'sdd-spec');
+
+  assert.ok(specEntry);
+  assert.match(specEntry.content, /specStageWorkOrderHandoff/);
+  assert.match(specEntry.content, /spec-manager/);
+  assert.match(specEntry.content, /spec\.md V3/);
+  assert.match(specEntry.content, /sdd spec close --branch <branch> --json/);
+  assert.match(specEntry.content, /only runtime primary spec artifact/);
+  assert.match(specEntry.content, /side logs/);
+  assert.match(specEntry.content, /final `specs\/<partition>\/spec\.md` ref\/hash plus boundary facts/);
+  assert.doesNotMatch(specEntry.content, /lifecycle decision reference/i);
+  assert.doesNotMatch(specEntry.content, /lifecycle_profile/);
+  assert.doesNotMatch(specEntry.content, /risk hard gates/i);
+  assert.doesNotMatch(specEntry.content, /evidence lands in spec review artifacts/i);
 });