@flancer32/skill-adsm-ctx 0.2.1 → 0.3.0

package/ctx/docs/product/overview.skin.en.md

@@ -1,38 +0,0 @@
-# Product Overview Skin
-
-- Path: `ctx/docs/product/overview.skin.en.md`
-- Changed: `20260813`
-
-## Purpose
-
-This skin preserves the high-level product identity of the skill package as a generic ADSM context lifecycle product.
-
-## Mental Model
-
-The product manages cognitive-context lifecycle rules and guidance, not a downstream business domain.
-
-## Scope
-
-Includes:
-
-- product identity, mission, and scope boundaries;
-- the generic and orchestration-oriented character of the skill;
-- the role split between humans and agents.
-
-Excludes:
-
-- detailed lifecycle mechanics;
-- internal implementation structure;
-- project-specific consumer-domain semantics.
-
-## Invariants
-
-- The product manages project cognitive context, not an external consumer project.
-- Agents do default lifecycle work; humans set guardrails, inspect outcomes, and correct drift.
-- The skill must remain generic and must not invent project-specific business or architecture meaning.
-- Installed project-facing templates keep only minimal ADSM bootstrap signals.
-- `overview.md` is an agent document, not a required human entry frame by methodology.
-
-## Agent Document
-
-`overview.md`

package/ctx/docs/product/roles.md

@@ -1,17 +0,0 @@
-# Product Roles
-
-- Path: `ctx/docs/product/roles.md`
-- Changed: `20260702`
-
-## Roles
-
-- **Human Supervisor** — defines goals, sets guardrails, reviews outcomes, and intervenes when agent work drifts from expected product or architecture boundaries.
-- **Agent** — performs most lifecycle work inside declared ADSM boundaries, including analysis, structure changes, audits, and controlled documentation compression.
-- **Developer** — maintains implementation and repository mechanics needed for the product to operate as a skill package.
-- **Context Maintainer** — evolves templates, validation rules, documentation quality audit guidance, documentation compression guidance, and upgrade conventions.
-
-## Authority Pattern
-
-- The human supervisor owns direction, acceptance, and boundary expansion.
-- The agent owns default operational execution inside documented boundaries.
-- The developer and context maintainer may be the same human, but their responsibilities remain distinct from the autonomous agent role.

package/ctx/docs/product/use-cases.md

@@ -1,15 +0,0 @@
-# Product Use Cases
-
-- Path: `ctx/docs/product/use-cases.md`
-- Changed: `20260708`
-
-## Use Cases
-
-- Initialize cognitive context in a repository so agents have a baseline `ctx/` structure, metadata, and local routing files.
-- Install the bundled skill payload into a caller-provided skills root so an agent skill host can load `adsm-ctx`.
-- Assess whether an existing repository has the required ADSM baseline, documentation levels, metadata, and projection shape.
-- Audit an existing documentation corpus against ADSM documentation quality criteria and produce evidence-backed findings.
-- Compress an existing `ctx/docs/` corpus while preserving accepted project meaning and skin-controlled meaning in matching agent documents.
-- Define or revise the reserved `ctx/agent/` boundary while leaving project-local tool materials outside the ADSM baseline.
-- Route documentation work toward specialized skills when project-specific context requires narrower expertise.
-- Upgrade a context when conventions or template structure change while preserving project-specific content.

package/src/Bootstrap/Cli.mjs

@@ -1,62 +0,0 @@
-// @ts-check
-
-/**
- * @namespace Fl32_Skill_Adsm_Ctx_Bootstrap_Cli
- * @description Parses CLI arguments for the ADSM context lifecycle application.
- */
-
-const usage = [
-  "Usage: adsm-ctx <command> [target-path]",
-  "Commands:",
-  "  init [target-path]",
-  "  design [target-path]",
-  "  validate [target-path]",
-  "  upgrade [target-path]",
-  "  install-skill <skills-root>",
-  "  --help",
-].join("\n");
-
-export default class Cli {
-  /**
-   * @param {object} deps
-   * @param {Fl32_Skill_Adsm_Ctx_Shared_Path} deps.pathService
-   */
-  constructor({pathService}) {
-    /**
-     * Parses CLI arguments.
-     *
-     * @param {object} params
-     * @param {string[]} params.cliArgs
-     * @param {string} params.projectRoot
-     * @returns {{
-     *   command?: string,
-     *   errors: string[],
-     *   helpRequested: boolean,
-     *   targetPath: string,
-     *   usage: string
-     * }}
-     */
-    this.parse = function ({cliArgs = [], projectRoot}) {
-      const [command, targetArg] = cliArgs;
-      const errors = [];
-      const helpRequested = !command || command === "--help" || command === "-h";
-      const targetPath = targetArg ? pathService.resolve(targetArg) : projectRoot;
-
-      if (!helpRequested) {
-        const supported = new Set(["init", "design", "validate", "upgrade", "install-skill"]);
-        if (!supported.has(command)) {
-          errors.push(`Unknown command: ${command}`);
-        }
-        if (command === "install-skill" && !targetArg) {
-          errors.push("Usage: adsm-ctx install-skill <skills-root>");
-        }
-      }
-
-      return {command, errors, helpRequested, targetPath, usage};
-    };
-  }
-}
-
-export const __deps__ = Object.freeze({
-  pathService: "Fl32_Skill_Adsm_Ctx_Shared_Path$",
-});

package/src/Bootstrap.mjs

@@ -1,108 +0,0 @@
-// @ts-check
-
-/**
- * @namespace Fl32_Skill_Adsm_Ctx_Bootstrap
- * @description TeqFW root CLI application component for ADSM context lifecycle operations.
- */
-
-export default class Bootstrap {
-  /**
-   * @param {object} deps
-   * @param {Fl32_Skill_Adsm_Ctx_Bootstrap_Cli} deps.cli
-   * @param {Fl32_Skill_Adsm_Ctx_Design_Service} deps.design
-   * @param {Fl32_Skill_Adsm_Ctx_Init_Service} deps.init
-   * @param {Fl32_Skill_Adsm_Ctx_Skill_Installer} deps.installer
-   * @param {Fl32_Skill_Adsm_Ctx_Upgrade_Service} deps.upgrade
-   * @param {Fl32_Skill_Adsm_Ctx_Validate_Service} deps.validate
-   */
-  constructor({cli, design, init, installer, upgrade, validate}) {
-    let stopping = false;
-
-    /**
-     * Runs the CLI application once.
-     *
-     * @param {object} params
-     * @param {string[]} params.cliArgs
-     * @param {string} params.projectRoot
-     * @returns {Promise<number>}
-     */
-    this.run = async ({cliArgs = [], projectRoot}) => {
-      const parsed = cli.parse({cliArgs, projectRoot});
-
-      if (parsed.helpRequested) {
-        process.stderr.write(`${parsed.usage}\n`);
-        return 0;
-      }
-
-      if (parsed.errors.length > 0) {
-        process.stderr.write(`${parsed.errors.join("\n")}\n`);
-        process.stderr.write(`${parsed.usage}\n`);
-        return 2;
-      }
-
-      if (parsed.command === "init") {
-        const result = await init.execute({targetPath: parsed.targetPath});
-        process.stdout.write(`${formatInitReport(result)}\n`);
-        return 0;
-      }
-
-      if (parsed.command === "design") {
-        process.stdout.write(`${await design.execute({targetPath: parsed.targetPath})}\n`);
-        return 0;
-      }
-
-      if (parsed.command === "validate") {
-        const result = await validate.execute({targetPath: parsed.targetPath});
-        process.stdout.write(`${validate.format({result})}\n`);
-        return result.ok ? 0 : 1;
-      }
-
-      if (parsed.command === "upgrade") {
-        const result = await upgrade.execute({targetPath: parsed.targetPath});
-        process.stdout.write(`${result.message}\n`);
-        return result.ok ? 0 : 1;
-      }
-
-      if (parsed.command === "install-skill") {
-        const targetDir = await installer.execute({targetRoot: parsed.targetPath});
-        process.stdout.write(`Installed skill payload to ${targetDir}\n`);
-        return 0;
-      }
-
-      process.stderr.write(`${parsed.usage}\n`);
-      return 2;
-    };
-
-    /**
-     * Stops the application.
-     *
-     * @returns {Promise<void>}
-     */
-    this.stop = async () => {
-      if (stopping) return;
-      stopping = true;
-    };
-  }
-}
-
-/**
- * @param {{ctxRoot: string, created: string[], skipped: string[]}} result
- * @returns {string}
- */
-function formatInitReport(result) {
-  const lines = [
-    `Initialized ADSM context in ${result.ctxRoot}`,
-    ...result.created.map((entry) => `Created: ${entry}`),
-    ...result.skipped.map((entry) => `Skipped: ${entry}`),
-  ];
-  return lines.join("\n");
-}
-
-export const __deps__ = Object.freeze({
-  cli: "Fl32_Skill_Adsm_Ctx_Bootstrap_Cli$",
-  design: "Fl32_Skill_Adsm_Ctx_Design_Service$",
-  init: "Fl32_Skill_Adsm_Ctx_Init_Service$",
-  installer: "Fl32_Skill_Adsm_Ctx_Skill_Installer$",
-  upgrade: "Fl32_Skill_Adsm_Ctx_Upgrade_Service$",
-  validate: "Fl32_Skill_Adsm_Ctx_Validate_Service$",
-});

package/test/integration/.gitkeep

@@ -1 +0,0 @@
-

package/test/integration/cli-help.test.mjs

@@ -1,15 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import path from 'node:path';
-import {spawnSync} from 'node:child_process';
-import {fileURLToPath} from 'node:url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const cliPath = path.join(__dirname, '..', '..', 'bin', 'cli.mjs');
-
-test('cli help works', () => {
-  const result = spawnSync('node', [cliPath, '--help'], {encoding: 'utf8'});
-  assert.equal(result.status, 0);
-  assert.match(result.stderr, /Usage: adsm-ctx/);
-});

package/test/integration/cli-init-validate.test.mjs

@@ -1,223 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import {spawnSync} from 'node:child_process';
-import {fileURLToPath} from 'node:url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const cliPath = path.join(__dirname, '..', '..', 'bin', 'cli.mjs');
-
-test('cli init creates files in current working directory by default', () => {
-  const sandboxRoot = fs.mkdtempSync(path.join('/tmp', 'adsm-ctx-cli-init-'));
-  const result = spawnSync('node', [cliPath, 'init'], {cwd: sandboxRoot, encoding: 'utf8'});
-
-  try {
-    assert.equal(result.status, 0, result.stderr);
-    assert.ok(fs.existsSync(path.join(sandboxRoot, 'ctx', 'adsm.json')));
-    const filesystemDoc = fs.readFileSync(path.join(sandboxRoot, 'ctx', 'docs', 'filesystem.md'), 'utf8');
-    const productDomainDoc = fs.readFileSync(path.join(sandboxRoot, 'ctx', 'docs', 'product', 'domain.md'), 'utf8');
-    assert.match(filesystemDoc, /This starter is not a completed repository map/);
-    assert.doesNotMatch(filesystemDoc, /npm package repository/);
-    assert.doesNotMatch(filesystemDoc, /node_modules/);
-    assert.match(productDomainDoc, /- Changed: `\d{8}`/);
-    assert.doesNotMatch(productDomainDoc, /- Changed: `YYYYMMDD`/);
-    assert.match(result.stdout, /Initialized ADSM context in /);
-  } finally {
-    fs.rmSync(sandboxRoot, {recursive: true, force: true});
-  }
-});
-
-test('cli validate succeeds after init in a clean project', () => {
-  const sandboxRoot = fs.mkdtempSync(path.join('/tmp', 'adsm-ctx-cli-validate-ok-'));
-
-  try {
-    const initResult = spawnSync('node', [cliPath, 'init'], {cwd: sandboxRoot, encoding: 'utf8'});
-    const validateResult = spawnSync('node', [cliPath, 'validate'], {cwd: sandboxRoot, encoding: 'utf8'});
-
-    assert.equal(initResult.status, 0, initResult.stderr);
-    assert.equal(validateResult.status, 0, validateResult.stderr);
-    assert.match(validateResult.stdout, /ADSM context validation passed/);
-    assert.match(validateResult.stdout, /Errors: 0/);
-    assert.match(validateResult.stdout, /Warnings: 0/);
-  } finally {
-    fs.rmSync(sandboxRoot, {recursive: true, force: true});
-  }
-});
-
-test('cli init does not overwrite existing metadata and validate succeeds after init', () => {
-  const sandboxRoot = fs.mkdtempSync(path.join('/tmp', 'adsm-ctx-cli-safe-init-'));
-
-  try {
-    fs.mkdirSync(path.join(sandboxRoot, 'ctx'), {recursive: true});
-    fs.writeFileSync(path.join(sandboxRoot, 'ctx', 'adsm.json'), '{"schema":"custom","version":"9.9.9"}\n');
-
-    const initResult = spawnSync('node', [cliPath, 'init'], {cwd: sandboxRoot, encoding: 'utf8'});
-    const validateResult = spawnSync('node', [cliPath, 'validate'], {cwd: sandboxRoot, encoding: 'utf8'});
-
-    assert.equal(initResult.status, 0, initResult.stderr);
-    assert.match(fs.readFileSync(path.join(sandboxRoot, 'ctx', 'adsm.json'), 'utf8'), /"schema":"custom"/);
-    assert.equal(validateResult.status, 1);
-    assert.match(validateResult.stdout, /Unexpected schema: custom/);
-  } finally {
-    fs.rmSync(sandboxRoot, {recursive: true, force: true});
-  }
-});
-
-test('cli validate reports missing context in empty directory', () => {
-  const sandboxRoot = fs.mkdtempSync(path.join('/tmp', 'adsm-ctx-cli-empty-'));
-
-  try {
-    const result = spawnSync('node', [cliPath, 'validate'], {cwd: sandboxRoot, encoding: 'utf8'});
-    assert.equal(result.status, 1);
-    assert.match(result.stdout, /Missing: ctx/);
-    assert.match(result.stdout, /Missing ctx\/adsm\.json/);
-  } finally {
-    fs.rmSync(sandboxRoot, {recursive: true, force: true});
-  }
-});
-
-test('cli validate reports invalid skin structure and reference', () => {
-  const sandboxRoot = fs.mkdtempSync(path.join('/tmp', 'adsm-ctx-cli-invalid-skin-'));
-
-  try {
-    const initResult = spawnSync('node', [cliPath, 'init'], {cwd: sandboxRoot, encoding: 'utf8'});
-    assert.equal(initResult.status, 0, initResult.stderr);
-
-    fs.writeFileSync(path.join(sandboxRoot, 'ctx', 'docs', 'product', 'domain.skin.en.md'), [
-      '# Product Domain Skin',
-      '',
-      '- Path: `ctx/docs/product/domain.skin.en.md`',
-      '- Changed: `20260708`',
-      '',
-      '## Purpose',
-      '',
-      'Human-facing control.',
-      '',
-      '## Scope',
-      '',
-      'Includes:',
-      '',
-      '- domain identity.',
-      '',
-      '## Invariants',
-      '',
-      '- Keep the domain stable.',
-      '- invariant 1.',
-      '- invariant 2.',
-      '- invariant 3.',
-      '- invariant 4.',
-      '- invariant 5.',
-      '- invariant 6.',
-      '- invariant 7.',
-      '- invariant 8.',
-      '- invariant 9.',
-      '- invariant 10.',
-      '- invariant 11.',
-      '- invariant 12.',
-      '',
-      '## Agent Document',
-      '',
-      '`other.md`',
-      '',
-    ].join('\n'));
-
-    const result = spawnSync('node', [cliPath, 'validate'], {cwd: sandboxRoot, encoding: 'utf8'});
-    assert.equal(result.status, 1);
-    assert.match(result.stdout, /Missing skin section "Mental Model": ctx\/docs\/product\/domain\.skin\.en\.md/);
-    assert.match(result.stdout, /Missing Excludes: block in Scope: ctx\/docs\/product\/domain\.skin\.en\.md/);
-    assert.match(result.stdout, /Skin agent document mismatch: ctx\/docs\/product\/domain\.skin\.en\.md references ctx\/docs\/product\/other\.md but expected ctx\/docs\/product\/domain\.md/);
-  } finally {
-    fs.rmSync(sandboxRoot, {recursive: true, force: true});
-  }
-});
-
-test('cli validate reports broken local markdown links as errors', () => {
-  const sandboxRoot = fs.mkdtempSync(path.join('/tmp', 'adsm-ctx-cli-broken-link-'));
-
-  try {
-    const initResult = spawnSync('node', [cliPath, 'init'], {cwd: sandboxRoot, encoding: 'utf8'});
-    assert.equal(initResult.status, 0, initResult.stderr);
-
-    fs.writeFileSync(path.join(sandboxRoot, 'ctx', 'docs', 'product', 'overview.md'), [
-      '# Product Overview',
-      '',
-      '- Path: `ctx/docs/product/overview.md`',
-      '- Changed: `20260708`',
-      '',
-      'See [domain](./missing.md).',
-      '',
-    ].join('\n'));
-
-    const result = spawnSync('node', [cliPath, 'validate'], {cwd: sandboxRoot, encoding: 'utf8'});
-    assert.equal(result.status, 1);
-    assert.match(result.stdout, /Missing linked document: \.\/missing\.md resolves to ctx\/docs\/product\/missing\.md/);
-    assert.match(result.stdout, /Errors: [1-9]/);
-  } finally {
-    fs.rmSync(sandboxRoot, {recursive: true, force: true});
-  }
-});
-
-test('cli validate succeeds with warnings only', () => {
-  const sandboxRoot = fs.mkdtempSync(path.join('/tmp', 'adsm-ctx-cli-warning-only-'));
-
-  try {
-    const initResult = spawnSync('node', [cliPath, 'init'], {cwd: sandboxRoot, encoding: 'utf8'});
-    assert.equal(initResult.status, 0, initResult.stderr);
-
-    fs.writeFileSync(path.join(sandboxRoot, 'ctx', 'docs', 'product', 'domain.skin.en.md'), [
-      '# Product Domain Skin',
-      '',
-      '- Path: `ctx/docs/product/domain.skin.en.md`',
-      '- Changed: `20260708`',
-      '',
-      '## Purpose',
-      '',
-      'See [domain](./domain.md#purpose) while keeping the human-facing summary compact.',
-      '',
-      '## Mental Model',
-      '',
-      'This is the human semantic frame.',
-      '',
-      '## Scope',
-      '',
-      'Includes:',
-      '',
-      '- domain identity.',
-      '',
-      'Excludes:',
-      '',
-      '- operational overload.',
-      '',
-      '## Invariants',
-      '',
-      '- Keep the domain stable.',
-      '- invariant 1.',
-      '- invariant 2.',
-      '- invariant 3.',
-      '- invariant 4.',
-      '- invariant 5.',
-      '- invariant 6.',
-      '- invariant 7.',
-      '- invariant 8.',
-      '- invariant 9.',
-      '- invariant 10.',
-      '- invariant 11.',
-      '- invariant 12.',
-      '',
-      '## Agent Document',
-      '',
-      '`domain.md`',
-      '',
-    ].join('\n'));
-
-    const result = spawnSync('node', [cliPath, 'validate'], {cwd: sandboxRoot, encoding: 'utf8'});
-    assert.equal(result.status, 0, result.stderr);
-    assert.match(result.stdout, /passed with warnings/i);
-    assert.match(result.stdout, /Errors: 0/);
-    assert.match(result.stdout, /Warnings: [1-9]/);
-  } finally {
-    fs.rmSync(sandboxRoot, {recursive: true, force: true});
-  }
-});

package/test/integration/cli-install-skill.test.mjs

@@ -1,41 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import {spawnSync} from 'node:child_process';
-import {fileURLToPath} from 'node:url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const cliPath = path.join(__dirname, '..', '..', 'bin', 'cli.mjs');
-
-test('cli install-skill installs current payload and replaces stale target content', () => {
-  const sandboxRoot = fs.mkdtempSync(path.join('/tmp', 'adsm-ctx-cli-install-skill-'));
-  const skillDir = path.join(sandboxRoot, 'adsm-ctx');
-  const staleFile = path.join(skillDir, 'stale.txt');
-  const installedSkill = path.join(skillDir, 'SKILL.md');
-  const installedReference = path.join(skillDir, 'references', 'context-lifecycle.md');
-  const installedTemplate = path.join(skillDir, 'templates', 'ctx', 'docs', 'architecture', 'overview.md');
-
-  try {
-    fs.mkdirSync(skillDir, {recursive: true});
-    fs.writeFileSync(staleFile, 'obsolete payload\n');
-    fs.writeFileSync(installedSkill, 'outdated skill\n');
-
-    const result = spawnSync('node', [cliPath, 'install-skill', sandboxRoot], {encoding: 'utf8'});
-
-    assert.equal(result.status, 0, result.stderr);
-    assert.match(result.stdout, new RegExp(`Installed skill payload to ${escapeRegExp(skillDir)}`));
-    assert.ok(fs.existsSync(installedSkill));
-    assert.ok(fs.existsSync(installedReference));
-    assert.ok(fs.existsSync(installedTemplate));
-    assert.match(fs.readFileSync(installedSkill, 'utf8'), /name: adsm-ctx/);
-    assert.equal(fs.existsSync(staleFile), false);
-  } finally {
-    fs.rmSync(sandboxRoot, {recursive: true, force: true});
-  }
-});
-
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}

package/test/unit/Bootstrap/Cli.test.mjs

@@ -1,23 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import Cli from '../../../src/Bootstrap/Cli.mjs';
-
-test('Cli uses project root as default target path', () => {
-  const cli = new Cli({pathService: {resolve: (value) => `/abs/${value}`}});
-  const result = cli.parse({cliArgs: ['init'], projectRoot: '/cwd'});
-  assert.equal(result.targetPath, '/cwd');
-  assert.equal(result.command, 'init');
-});
-
-test('Cli resolves explicit target path', () => {
-  const cli = new Cli({pathService: {resolve: (value) => `/abs/${value}`}});
-  const result = cli.parse({cliArgs: ['validate', 'demo'], projectRoot: '/cwd'});
-  assert.equal(result.targetPath, '/abs/demo');
-});
-
-test('Cli requires target root for install-skill', () => {
-  const cli = new Cli({pathService: {resolve: (value) => value}});
-  const result = cli.parse({cliArgs: ['install-skill'], projectRoot: '/cwd'});
-  assert.match(result.errors.join('\n'), /install-skill <skills-root>/);
-});

package/test/unit/Bootstrap.test.mjs

@@ -1,53 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import Bootstrap from '../../src/Bootstrap.mjs';
-
-test('Bootstrap routes init command and reports created and skipped entries', async () => {
-  const writes = {stdout: [], stderr: []};
-  const stdoutWrite = process.stdout.write;
-  const stderrWrite = process.stderr.write;
-  process.stdout.write = (chunk) => { writes.stdout.push(String(chunk)); return true; };
-  process.stderr.write = (chunk) => { writes.stderr.push(String(chunk)); return true; };
-
-  try {
-    const app = new Bootstrap({
-      cli: {parse: () => ({command: 'init', errors: [], helpRequested: false, targetPath: '/project', usage: 'usage'})},
-      design: {execute: async () => ''},
-      init: {execute: async () => ({ctxRoot: '/project/ctx', created: ['ctx'], skipped: ['ctx/adsm.json']})},
-      installer: {execute: async () => ''},
-      upgrade: {execute: async () => ({ok: true, message: ''})},
-      validate: {execute: async () => ({ok: true}), format: () => ''},
-    });
-
-    const code = await app.run({cliArgs: ['init'], projectRoot: '/project'});
-    assert.equal(code, 0);
-    assert.match(writes.stdout.join(''), /Created: ctx/);
-    assert.match(writes.stdout.join(''), /Skipped: ctx\/adsm\.json/);
-  } finally {
-    process.stdout.write = stdoutWrite;
-    process.stderr.write = stderrWrite;
-  }
-});
-
-test('Bootstrap prints help and exits with zero', async () => {
-  const writes = {stdout: [], stderr: []};
-  const stderrWrite = process.stderr.write;
-  process.stderr.write = (chunk) => { writes.stderr.push(String(chunk)); return true; };
-
-  try {
-    const app = new Bootstrap({
-      cli: {parse: () => ({errors: [], helpRequested: true, usage: 'usage'})},
-      design: {execute: async () => ''},
-      init: {execute: async () => ({})},
-      installer: {execute: async () => ''},
-      upgrade: {execute: async () => ({ok: true, message: ''})},
-      validate: {execute: async () => ({ok: true}), format: () => ''},
-    });
-    const code = await app.run({cliArgs: ['--help'], projectRoot: '/project'});
-    assert.equal(code, 0);
-    assert.equal(writes.stderr.join(''), 'usage\n');
-  } finally {
-    process.stderr.write = stderrWrite;
-  }
-});

package/test/unit/Design/Service.test.mjs

@@ -1,11 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import Service from '../../../src/Design/Service.mjs';
-
-test('Design service references questionnaire and orchestration', async () => {
-  const service = new Service();
-  const result = await service.execute({targetPath: '/project'});
-  assert.match(result, /design-questionnaire\.md/);
-  assert.match(result, /specialized ADSM skills/);
-});

package/test/unit/Init/Service.test.mjs

@@ -1,51 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import Service from '../../../src/Init/Service.mjs';
-
-test('Init service creates metadata only when missing', async () => {
-  const writes = [];
-  const fs = {
-    existing: new Set(),
-    existsSync(path) { return this.existing.has(path); },
-    mkdirSync(path) { this.existing.add(path); },
-    writeFileSync(path, content) { this.existing.add(path); writes.push({path, content}); },
-  };
-  const copyDirectory = {
-    copyMissing: ({created}) => created.push('ctx'),
-  };
-  const service = new Service({
-    copyDirectory,
-    fs,
-    metadata: {create: () => ({schema: 'adsm-context', version: '0.1.0'})},
-    pathService: {join: (...parts) => parts.join('/'), resolve: (value) => value},
-    url: {fileURLToPath: () => '/templates/ctx'},
-  });
-
-  const result = await service.execute({targetPath: '/project'});
-  assert.equal(result.projectRoot, '/project');
-  assert.ok(result.created.includes('ctx'));
-  assert.ok(result.created.includes('AGENTS.md'));
-  assert.ok(result.created.includes('ctx/adsm.json'));
-  assert.match(writes.find((item) => item.path === '/project/ctx/adsm.json').content, /"version": "0\.1\.0"/);
-});
-
-test('Init service skips existing root agents and metadata', async () => {
-  const fs = {
-    existing: new Set(['/project/AGENTS.md', '/project/ctx/adsm.json']),
-    existsSync(path) { return this.existing.has(path); },
-    mkdirSync() {},
-    writeFileSync() { throw new Error('unexpected write'); },
-  };
-  const service = new Service({
-    copyDirectory: {copyMissing() {}},
-    fs,
-    metadata: {create: () => ({schema: 'adsm-context', version: '0.1.0'})},
-    pathService: {join: (...parts) => parts.join('/'), resolve: (value) => value},
-    url: {fileURLToPath: () => '/templates/ctx'},
-  });
-
-  const result = await service.execute({targetPath: '/project'});
-  assert.ok(result.skipped.includes('AGENTS.md'));
-  assert.ok(result.skipped.includes('ctx/adsm.json'));
-});