fix(cli): make smart-cli usable for automation — DI, rulesets, exit codes, batch init

Analyzed + fixed runtime defects that made the CLI unusable non-interactively.

- evaluate/drift no longer crash: thread IConfigParser + RulesetValidator through
  the shared core-domain composition root (kind-evaluators, architecture-drift);
  register ArchitectureDriftService as a provider and inject it.
- Self-contained rulesets: bundle <repo>/src/rulesets into the CLI package
  (copy-rulesets.js, prebuild/prepublishOnly; gitignored — regenerated) + a
  rulesets-resolver that resolves from the install (__dirname), --core/profile as
  override, NEVER process.cwd(). Fixes topology-recommend/phase-artifacts ENOENT.
- Exit codes: BaseEvolithCommand.handleError + json error paths set exitCode=1
  (nest-commander swallowed errors and exited 0).
- init non-interactive: --config <setup.json> or --name --yes (+ runtime/monorepo/
  arch/db) run prompt-free; copy-assets.js ships config JSONs to dist so init
  completes. scaffold guards a missing workspace (NOT_A_SATELLITE, exit 1) instead
  of raw spawn ENOENT.
- test hygiene: mock the npm-registry version fetch (no network / WARN noise).

Build clean; 919 unit tests. Verified live from a scratch dir: evaluate/drift/
topology succeed with correct exit codes, and `init --name x --yes` scaffolds a
satellite non-interactively.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: beyondnetPeru

src/packages/core-domain/src/application/validators/architecture-drift.service.ts

@@ -1,5 +1,5 @@
 import * as path from 'path';
-import { IFileSystem, ILogger } from '../../domain/interfaces';
+import { IFileSystem, ILogger, IConfigParser } from '../../domain/interfaces';
 import { RulesetValidatorService, ArchitectureValidationResult, ValidationIssue } from './ruleset-validator.service';
 
 export interface DriftReport {
@@ -50,12 +50,19 @@ export class ArchitectureDriftService {
   private readonly logger: ILogger;
   private readonly validator: RulesetValidatorService;
 
-  constructor(corePath?: string, options?: { fileSystem?: IFileSystem; logger?: ILogger; validator?: RulesetValidatorService }) {
+  constructor(corePath?: string, options?: { fileSystem?: IFileSystem; logger?: ILogger; configParser?: IConfigParser; validator?: RulesetValidatorService }) {
     if (!options?.fileSystem) throw new Error('IFileSystem is required');
     if (!options?.logger) throw new Error('ILogger is required');
     this.fs = options.fileSystem;
     this.logger = options.logger;
-    this.validator = options?.validator ?? new RulesetValidatorService({ fileSystem: this.fs, logger: this.logger });
+    // The default RulesetValidatorService requires a configParser; when no
+    // explicit validator is supplied, forward the configParser so the drift
+    // service is usable from the shared evaluator composition root.
+    this.validator = options?.validator ?? new RulesetValidatorService({
+      fileSystem: this.fs,
+      logger: this.logger,
+      configParser: options.configParser,
+    });
   }
 
   async detectDrift(options: DriftDetectionOptions): Promise<DriftReport> {

src/packages/core-domain/src/evaluation/kind-evaluators.ts

@@ -19,9 +19,10 @@
 import { Verdict } from '../domain/verdict/verdict';
 import { CANONICAL_PHASE_IDS, normalizePhaseId } from '../domain/sdlc/phase-id';
 import type { PhaseId } from '../domain/sdlc/phase-id';
-import type { IFileSystem, ILogger } from '../domain/interfaces';
+import type { IFileSystem, ILogger, IConfigParser } from '../domain/interfaces';
 import type { KindEvaluator } from './ports/kind-evaluator.port';
 import { ArchitectureDriftService } from '../application/validators/architecture-drift.service';
+import type { RulesetValidatorService } from '../application/validators/ruleset-validator.service';
 import { PhaseGateValidatorService } from '../application/validators/phase-gate-validator.service';
 import { EvaluateGateUseCase } from '../application/use-cases/evaluate-gate.use-case';
 import { ProposePhaseAdvanceUseCase } from '../application/use-cases/propose-phase-advance.use-case';
@@ -522,6 +523,20 @@ export function createPhaseArtifactKindEvaluator(
 export interface DefaultKindEvaluatorDeps {
   readonly fileSystem: IFileSystem;
   readonly logger: ILogger;
+  /**
+   * Config parser used by the architecture evaluator's default RulesetValidator.
+   * Optional for backward compatibility; when omitted the drift service falls back
+   * to its own default (which requires a parser and would otherwise throw). Every
+   * surface should pass its IConfigParser so the architecture kind evaluates.
+   */
+  readonly configParser?: IConfigParser;
+  /**
+   * A fully-wired RulesetValidatorService for the architecture evaluator. Prefer
+   * passing this: the default validator also needs an IRulesetRepository, whose
+   * concrete implementation lives outside core-domain (infra-providers), so a
+   * surface that owns one should inject it here rather than rely on the default.
+   */
+  readonly rulesetValidator?: RulesetValidatorService;
   /** Resolves the Core repository path when a context/workspace omits corePath. */
   readonly resolveCorePath: () => string;
 }
@@ -533,13 +548,18 @@ export interface DefaultKindEvaluatorDeps {
  * the structural guarantee behind BR-008 parity.
  */
 export function createDefaultKindEvaluators(deps: DefaultKindEvaluatorDeps): KindEvaluator[] {
-  const { fileSystem, logger, resolveCorePath } = deps;
+  const { fileSystem, logger, configParser, rulesetValidator, resolveCorePath } = deps;
 
   const validatorFactory = (corePath?: string) =>
     new PhaseGateValidatorService(corePath, { fileSystem, logger });
   const evaluateGate = new EvaluateGateUseCase(validatorFactory);
   const proposeAdvance = new ProposePhaseAdvanceUseCase(evaluateGate);
-  const driftService = new ArchitectureDriftService(undefined, { fileSystem, logger });
+  const driftService = new ArchitectureDriftService(undefined, {
+    fileSystem,
+    logger,
+    configParser,
+    validator: rulesetValidator,
+  });
   const topologyCatalog = new TopologyCatalogService(fileSystem, logger);
 
   const blueprintExists = async (corePath: string, blueprintRef: string): Promise<boolean> => {

src/sdk/cli/.gitignore

@@ -15,3 +15,8 @@ MASTER_INDEX.md
 
 # Local env overrides
 .env.local
+
+# Bundled canonical rulesets — copied from src/rulesets at build time (copy-rulesets.js).
+# Source of truth is src/rulesets; these are regenerated on prebuild/prepublishOnly.
+rulesets/*
+!rulesets/agents/

src/sdk/cli/package.json

@@ -10,7 +10,10 @@
     "doc": "docs"
   },
   "scripts": {
-    "build": "tsc",
+    "copy-rulesets": "node scripts/copy-rulesets.js",
+    "copy-assets": "node scripts/copy-assets.js",
+    "prebuild": "npm run copy-rulesets",
+    "build": "tsc && npm run copy-assets",
     "start": "node dist/main.js",
     "start:dev": "tsc -w & node dist/main.js",
     "build:policy": "npm run build:policy --prefix ../../",
@@ -23,7 +26,7 @@
     "test:e2e": "NODE_OPTIONS=--max-old-space-size=4096 jest --config ./test/jest-e2e.json --runInBand --no-bail",
     "mcp:smoke": "npm run build && node examples/mcp-test.js",
     "lint": "eslint src --ext .ts",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run copy-rulesets && npm run build && npm run copy-assets"
   },
   "keywords": [
     "evolith",
@@ -53,6 +56,7 @@
   },
   "files": [
     "dist/",
+    "rulesets/",
     "shell/",
     "templates/",
     "README.md",

src/sdk/cli/scripts/copy-assets.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+/**
+ * copy-assets — copy non-TS runtime assets that `tsc` does not emit into `dist/`.
+ *
+ * The catalog loader reads JSON catalogs from `dist/config/*.json`
+ * (`__dirname/../../config`), but `tsc` only compiles `.ts`. Without this step an
+ * installed (or built-from-dist) CLI cannot run `init` — it fails with
+ * `ENOENT ... dist/config/runtimes.json`. Copy the source `config/*.json`
+ * (and any other non-TS assets) into `dist/config/` after compilation.
+ *
+ * Runs POST-tsc (tsc regenerates dist), and is idempotent.
+ */
+const fs = require('fs');
+const path = require('path');
+
+const cliRoot = path.resolve(__dirname, '..');
+const srcConfig = path.join(cliRoot, 'src', 'config');
+const destConfig = path.join(cliRoot, 'dist', 'config');
+
+if (!fs.existsSync(destConfig)) fs.mkdirSync(destConfig, { recursive: true });
+
+let copied = 0;
+if (fs.existsSync(srcConfig)) {
+  for (const entry of fs.readdirSync(srcConfig, { withFileTypes: true })) {
+    if (entry.isFile() && entry.name.endsWith('.json')) {
+      fs.copyFileSync(path.join(srcConfig, entry.name), path.join(destConfig, entry.name));
+      copied++;
+    }
+  }
+}
+
+console.log(`[copy-assets] copied ${copied} config JSON file(s) → dist/config/`);

src/sdk/cli/scripts/copy-rulesets.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+/**
+ * copy-rulesets — bundle the canonical rulesets into the CLI package so an
+ * installed `@beyondnet/evolith-cli` is self-contained (no repo checkout needed).
+ *
+ * Copies `<repo root>/src/rulesets` → `<cli>/rulesets`, MERGING into the
+ * existing `rulesets/` dir (which already holds agent fixtures) rather than
+ * replacing it. Idempotent; safe to run on every build and before publish.
+ */
+const fs = require('fs');
+const path = require('path');
+
+const cliRoot = path.resolve(__dirname, '..');
+// <cli> = src/sdk/cli  →  repo root is three levels up; canonical rulesets live
+// at <repo>/src/rulesets.
+const canonical = path.resolve(cliRoot, '..', '..', 'rulesets');
+const dest = path.join(cliRoot, 'rulesets');
+
+function copyDir(from, to) {
+  if (!fs.existsSync(to)) fs.mkdirSync(to, { recursive: true });
+  for (const entry of fs.readdirSync(from, { withFileTypes: true })) {
+    const src = path.join(from, entry.name);
+    const dst = path.join(to, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(src, dst);
+    } else if (entry.isFile()) {
+      fs.copyFileSync(src, dst);
+    }
+  }
+}
+
+if (!fs.existsSync(canonical)) {
+  // In an installed/detached context there is no source tree to copy from; the
+  // rulesets are expected to be already bundled. Do not fail the build.
+  console.warn(`[copy-rulesets] canonical source not found at ${canonical}; skipping (already bundled?)`);
+  process.exit(0);
+}
+
+copyDir(canonical, dest);
+console.log(`[copy-rulesets] bundled canonical rulesets → ${path.relative(cliRoot, dest)}/`);

src/sdk/cli/src/app.module.ts

@@ -38,6 +38,7 @@ import { EvaluateGateUseCase } from '@beyondnet/evolith-core-domain/application/
 import { PhaseGateValidatorService } from '@beyondnet/evolith-core-domain/application/validators/phase-gate-validator.service';
 import { ProposePhaseAdvanceUseCase } from '@beyondnet/evolith-core-domain/application/use-cases/propose-phase-advance.use-case';
 import { RulesetValidatorService } from '@beyondnet/evolith-core-domain/application/validators/ruleset-validator.service';
+import { ArchitectureDriftService } from '@beyondnet/evolith-core-domain/application/validators/architecture-drift.service';
 import type { IFileSystem, ILogger, IConfigParser } from '@beyondnet/evolith-core-domain/domain/interfaces';
 import { PromptService } from './infrastructure/prompts/prompt.service';
 import { WizardService } from './infrastructure/prompts/wizard.service';
@@ -94,7 +95,6 @@ import { PluginModule } from './infrastructure/plugins/plugin.module';
     AliasCommand,
     SatelliteCreateCommand,
     ChatCommand,
-    ValidateSatelliteUseCase,
     EvaluateGateUseCase,
     ProposePhaseAdvanceUseCase,
     {
@@ -109,6 +109,23 @@ import { PluginModule } from './infrastructure/plugins/plugin.module';
       },
       inject: ['IFileSystem', 'ILogger', 'IConfigParser'],
     },
+    {
+      // ValidateSatelliteUseCase constructs a bare RulesetValidatorService when
+      // given no validator — which throws `IConfigParser is required` at DI time.
+      // Inject the fully-wired validator so `evaluate`/`validate` construct cleanly.
+      provide: ValidateSatelliteUseCase,
+      useFactory: (validator: RulesetValidatorService) => new ValidateSatelliteUseCase(validator),
+      inject: [RulesetValidatorService],
+    },
+    {
+      // ArchitectureDriftService requires fileSystem + logger; the DriftCommand
+      // previously constructed it with `new ArchitectureDriftService()` → throws
+      // `IFileSystem is required`. Wire it here and inject into the command.
+      provide: ArchitectureDriftService,
+      useFactory: (fs: IFileSystem, logger: ILogger, validator: RulesetValidatorService) =>
+        new ArchitectureDriftService(undefined, { fileSystem: fs, logger, validator }),
+      inject: ['IFileSystem', 'ILogger', RulesetValidatorService],
+    },
     PromptService,
     WizardService,
     InitWizardCommand,

src/sdk/cli/src/commands/architecture/scaffold.command.spec.ts

@@ -34,6 +34,9 @@ describe('ScaffoldCommand', () => {
     (NxWorkspaceStrategy as jest.Mock).mockImplementation(() => mockStrategy);
     mockSpinner.mockReturnValue(mockSpinnerInstance);
     command = new ScaffoldCommand();
+    // By default assume a valid Nx workspace so the pre-spawn guard passes; the
+    // dedicated guard test below overrides this to exercise the failure path.
+    jest.spyOn(command as any, 'checkWorkspace').mockReturnValue(undefined);
   });
 
   describe('run', () => {
@@ -277,6 +280,23 @@ describe('ScaffoldCommand', () => {
       expect(envelope.error.message).toContain('--frontend');
     });
 
+    it('should emit an actionable NOT_A_SATELLITE envelope when no workspace exists', async () => {
+      (command as any).checkWorkspace.mockReturnValue(
+        'No workspace found at /x/src. Run `smart-cli init` first.',
+      );
+
+      await command.run([], { format: 'json', frontend: 'react', orm: 'prisma', phase: '1' });
+
+      const envelope = JSON.parse(logSpy.mock.calls.find((c: any[]) => {
+        try { return JSON.parse(c[0]).success === false; } catch { return false; }
+      })![0]);
+      expect(envelope.success).toBe(false);
+      expect(envelope.error.code).toBe('NOT_A_SATELLITE');
+      expect(envelope.error.message).toContain('smart-cli init');
+      // The guard must short-circuit before any strategy work.
+      expect(mockStrategy.installDependencies).not.toHaveBeenCalled();
+    });
+
     it('should emit error envelope on strategy failure', async () => {
       mockStrategy.installDependencies.mockRejectedValueOnce(new Error('npm failed'));
 

src/sdk/cli/src/commands/architecture/scaffold.command.ts

@@ -1,3 +1,5 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { Command, Option } from 'nest-commander';
 import { randomUUID } from 'node:crypto';
 import { BaseEvolithCommand } from '../../infrastructure/cli/base-command';
@@ -36,6 +38,25 @@ export class ScaffoldCommand extends BaseEvolithCommand {
       this.strategy.setDryRun(dryRun);
     }
 
+    // Guard: the Nx strategy runs `npm install` / `nx g` in `<cwd>/src`. If that
+    // workspace does not exist, the spawn fails deep with a raw `spawn ENOENT`.
+    // Fail fast with an actionable message instead. Dry-run doesn't spawn, so skip.
+    if (!dryRun) {
+      const workspaceError = this.checkWorkspace();
+      if (workspaceError) {
+        if (json) {
+          process.exitCode = 1;
+          console.log(JSON.stringify(createErrorEnvelope(
+            'NOT_A_SATELLITE',
+            workspaceError,
+            { ...meta, durationMs: Date.now() - startedAt },
+          ), null, 2));
+          return;
+        }
+        throw new Error(workspaceError);
+      }
+    }
+
     if (json) {
       try {
         const frontendFramework = options?.frontend as string;
@@ -233,6 +254,32 @@ export class ScaffoldCommand extends BaseEvolithCommand {
     this.promptService.showOutro('Completed');
   }
 
+  /**
+   * The Nx strategy operates in `<cwd>/src`. Verify that directory exists and is
+   * an Nx workspace before we spawn any `npm`/`nx` process there. Returns an
+   * actionable error message, or `undefined` when the workspace is usable.
+   */
+  private checkWorkspace(): string | undefined {
+    const cwd = process.cwd();
+    const workspaceDir = path.join(cwd, 'src');
+    if (!fs.existsSync(workspaceDir)) {
+      return (
+        `No workspace found at ${workspaceDir}. Run \`smart-cli init\` first to ` +
+        `scaffold a satellite, then re-run \`smart-cli architecture scaffold\`.`
+      );
+    }
+    const isNxWorkspace =
+      fs.existsSync(path.join(workspaceDir, 'nx.json')) ||
+      fs.existsSync(path.join(workspaceDir, 'package.json'));
+    if (!isNxWorkspace) {
+      return (
+        `${workspaceDir} exists but is not an Nx workspace (no nx.json/package.json). ` +
+        `Run \`smart-cli init\` first to scaffold the base workspace.`
+      );
+    }
+    return undefined;
+  }
+
   @Option({
     flags: '--frontend [framework]',
     description: 'Framework para el frontend (react, angular)',

src/sdk/cli/src/commands/drift/drift.command.spec.ts

@@ -69,7 +69,14 @@ describe('DriftCommand', () => {
 
   beforeEach(() => {
     // GT-345: real PromptService so showError routes through the mocked @clack/prompts log.error.
-    command = new DriftCommand(new PromptService());
+    // The drift service is now injected (previously constructed internally); pass a
+    // mock exposing the same three methods the command calls.
+    const driftServiceMock = {
+      detectDrift: mockDetectDrift,
+      getDriftHistory: mockGetDriftHistory,
+      getDriftTrend: mockGetDriftTrend,
+    } as unknown as ArchitectureDriftService;
+    command = new DriftCommand(driftServiceMock, new PromptService());
     logSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
     exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined as never);
     jest.clearAllMocks();