@polymorphism-tech/morph-spec 8.2.0 → 8.3.0

package/src/lib/stack/stack-profile.js

@@ -51,24 +51,55 @@ function readStack(cwd) {
   }
 }
 
+/** Merge two or more profiles' validator lists (deduped) and boolean flags. */
+function mergeProfiles(profiles) {
+  return {
+    isDotnet: profiles.some((p) => p.isDotnet),
+    isNextjs: profiles.some((p) => p.isNextjs),
+    defaultValidators: [...new Set(profiles.flatMap((p) => p.defaultValidators))],
+    checkpointValidators: [...new Set(profiles.flatMap((p) => p.checkpointValidators))],
+    buildCommand: profiles.map((p) => p.buildCommand).find(Boolean) ?? null,
+  };
+}
+
 /**
  * Get the StackProfile for the current project.
+ *
+ * `stack` may be a compound value (e.g. "dotnet-nextjs", "dotnet+nextjs") —
+ * the framework's own convention for monorepos (see stack-filter.js's
+ * getProjectTags, which splits project.stack the same way). Each segment is
+ * resolved independently and matching profiles are merged, instead of the
+ * whole compound string failing every exact-match check and silently
+ * collapsing to the empty profile (0 default validators).
  */
 export function getStackProfile(cwd, stackOverride) {
   const root = cwd ?? process.cwd();
   const raw = stackOverride ?? readStack(root);
   const stack = raw?.toLowerCase() ?? 'unknown';
 
-  let profile;
-  if (NEXTJS_STACKS.has(stack)) {
-    profile = PROFILES.nextjs;
-  } else if (NO_VALIDATOR_STACKS.has(stack)) {
-    profile = PROFILES.empty;
-  } else if (DOTNET_STACKS.has(stack) || stack === 'unknown') {
-    profile = PROFILES.dotnet;
-  } else {
-    profile = PROFILES.empty;
+  const segments = stack.split(/[-+]/).filter(Boolean);
+
+  // Single-segment stack (the overwhelming common case): resolve exactly as
+  // before, byte-for-byte, including the 'unknown' → dotnet fallback.
+  if (segments.length <= 1) {
+    let profile;
+    if (NEXTJS_STACKS.has(stack)) {
+      profile = PROFILES.nextjs;
+    } else if (NO_VALIDATOR_STACKS.has(stack)) {
+      profile = PROFILES.empty;
+    } else if (DOTNET_STACKS.has(stack) || stack === 'unknown') {
+      profile = PROFILES.dotnet;
+    } else {
+      profile = PROFILES.empty;
+    }
+    return { stack, ...profile };
   }
 
+  // Compound stack: resolve each recognized segment and merge.
+  const matched = [];
+  if (segments.some((s) => DOTNET_STACKS.has(s))) matched.push(PROFILES.dotnet);
+  if (segments.some((s) => NEXTJS_STACKS.has(s))) matched.push(PROFILES.nextjs);
+
+  const profile = matched.length > 0 ? mergeProfiles(matched) : PROFILES.empty;
   return { stack, ...profile };
 }

package/src/lib/tasks/tasks-json-parser.js

@@ -98,6 +98,27 @@ export async function parseTasksJson(filePath) {
   return data;
 }
 
+/**
+ * Lenient variant for read-only analysis commands (e.g. `morph-spec dag`):
+ * a missing `version` field is defaulted to "1.0" instead of failing
+ * validation — legacy tasks.json predating the field is still analyzable.
+ * All other schema errors still throw exactly like `parseTasksJson`.
+ *
+ * @param {string} filePath - Absolute path to tasks.json
+ * @returns {Promise<{ data: object, versionDefaulted: boolean }>}
+ */
+export async function parseTasksJsonLenient(filePath) {
+  const data = await fs.readJson(filePath);
+  const versionDefaulted = data.version === undefined;
+  if (versionDefaulted) data.version = '1.0';
+
+  const { valid, errors } = validateTasksJson(data);
+  if (!valid) {
+    throw new Error(`Invalid tasks.json:\n  ${errors.join('\n  ')}`);
+  }
+  return { data, versionDefaulted };
+}
+
 /**
  * Synchronous variant — used by hooks.
  */

package/src/lib/tasks/test-runner.js

@@ -4,13 +4,16 @@
  * Resolution order for test command:
  *   1. .morph/config/config.json → project.testCommand
  *   2. .sln or .csproj present at project root → "dotnet test"
- *   3. package.json present AND has scripts.test → "npm test"
- *   4. null (no test suite detected)
+ *   3. Nested *Tests.csproj anywhere in the tree (monorepo without a root
+ *      .sln) → "dotnet test <proj> --nologo -v q" for each match
+ *   4. package.json present AND has scripts.test → "npm test"
+ *   5. null (no test suite detected)
  */
 
 import { execSync } from 'child_process';
 import { existsSync, readFileSync, readdirSync } from 'fs';
 import { join } from 'path';
+import { globSync } from 'glob';
 
 /**
  * Resolve the test command for a project.
@@ -46,7 +49,26 @@ export function resolveTestCommand(projectPath = '.') {
     // Unreadable project directory — fall through to next detection
   }
 
-  // 3. package.json present AND has scripts.test → npm test
+  // 3. No root-level project file — look for a nested test project
+  // (e.g. tests/MyApp.Tests/MyApp.Tests.csproj), common in monorepos that
+  // have no root .sln. Run each matched project explicitly rather than a
+  // bare `dotnet test` (which finds nothing to build at the root).
+  try {
+    const testProjects = globSync('**/*Tests.csproj', {
+      cwd: projectPath,
+      ignore: ['**/bin/**', '**/obj/**', '**/node_modules/**'],
+    });
+    if (testProjects.length > 0) {
+      return testProjects
+        .sort()
+        .map((p) => `dotnet test "${p}" --nologo -v q`)
+        .join(' && ');
+    }
+  } catch {
+    // Glob failure — fall through to next detection
+  }
+
+  // 4. package.json present AND has scripts.test → npm test
   const packageJsonPath = join(projectPath, 'package.json');
   if (existsSync(packageJsonPath)) {
     try {
@@ -59,7 +81,7 @@ export function resolveTestCommand(projectPath = '.') {
     }
   }
 
-  // 4. Nothing found
+  // 5. Nothing found
   return null;
 }
 

package/src/lib/telemetry/telemetry-reader.js

@@ -0,0 +1,103 @@
+/**
+ * Telemetry aggregation — reads the append-only harness event stream
+ * (.morph/logs/events.jsonl, written by the telemetry-log hook) and summarizes
+ * the whole execution path: which skills ran, which personas were dispatched,
+ * which standards (knowledge base) were read, the tool mix, and the prompts.
+ *
+ * Pure aggregation (`aggregateTelemetry`) is separated from disk I/O
+ * (`loadTelemetry`) so the summary logic is unit-testable without fixtures —
+ * the same split fleet-scanner uses. CLI-side; runs in the target project cwd.
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+const EVENTS_FILE = join('.morph', 'logs', 'events.jsonl');
+
+/**
+ * Read the raw event stream from a project root. A corrupt/truncated line is
+ * skipped, not fatal. Returns [] when there is no log.
+ *
+ * @param {string} [projectPath]
+ * @returns {Object[]}
+ */
+export function loadTelemetry(projectPath) {
+  try {
+    const p = join(projectPath || process.cwd(), EVENTS_FILE);
+    if (!existsSync(p)) return [];
+    const events = [];
+    for (const line of readFileSync(p, 'utf-8').split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try { events.push(JSON.parse(trimmed)); } catch { /* skip corrupt line */ }
+    }
+    return events;
+  } catch {
+    return [];
+  }
+}
+
+function rank(map) {
+  return [...map.entries()]
+    .map(([name, count]) => ({ name, count }))
+    .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+}
+
+/**
+ * Summarize an event stream.
+ *
+ * @param {Object[]} events - raw events (from loadTelemetry)
+ * @param {{ feature?: string }} [opts] - optional feature filter
+ * @returns {{
+ *   total: number,
+ *   skills: Array<{name:string,count:number}>,
+ *   personas: Array<{name:string,count:number}>,
+ *   standards: Array<{path:string,count:number}>,
+ *   tools: Array<{name:string,count:number}>,
+ *   prompts: Array<{ts:string,source:'user'|'agent',feature:?string,phase:?string,text:string}>,
+ *   features: string[]
+ * }}
+ */
+export function aggregateTelemetry(events, opts = {}) {
+  const scoped = opts.feature
+    ? (events || []).filter(e => e.feature === opts.feature)
+    : (events || []);
+
+  const skills = new Map();
+  const personas = new Map();
+  const standards = new Map();
+  const tools = new Map();
+  const features = new Set();
+  const prompts = [];
+
+  for (const e of scoped) {
+    if (e.tool) tools.set(e.tool, (tools.get(e.tool) || 0) + 1);
+    if (e.feature) features.add(e.feature);
+
+    if (e.tool === 'Skill' && e.skill) {
+      skills.set(e.skill, (skills.get(e.skill) || 0) + 1);
+    } else if ((e.tool === 'Agent' || e.tool === 'Task') && e.persona) {
+      personas.set(e.persona, (personas.get(e.persona) || 0) + 1);
+    }
+
+    if (e.kind === 'standard' && e.target) {
+      standards.set(e.target, (standards.get(e.target) || 0) + 1);
+    }
+
+    if (e.tool === 'UserPrompt' && typeof e.prompt === 'string') {
+      prompts.push({ ts: e.ts, source: 'user', feature: e.feature ?? null, phase: e.phase ?? null, text: e.prompt });
+    } else if ((e.tool === 'Agent' || e.tool === 'Task') && typeof e.prompt === 'string' && e.prompt) {
+      prompts.push({ ts: e.ts, source: 'agent', feature: e.feature ?? null, phase: e.phase ?? null, text: e.prompt });
+    }
+  }
+
+  return {
+    total: scoped.length,
+    skills: rank(skills),
+    personas: rank(personas),
+    standards: rank(standards).map(({ name, count }) => ({ path: name, count })),
+    tools: rank(tools),
+    prompts,
+    features: [...features],
+  };
+}

package/src/lib/validators/validation-runner.js

@@ -1,8 +1,8 @@
 /**
  * MORPH-SPEC Validation Runner
  *
- * Unified orchestrator that runs the right validators based on the feature's
- * active agents and decisions. Called by task-done before marking tasks complete.
+ * Unified orchestrator that runs the right validators based on the project's
+ * stack profile. Called by task-done before marking tasks complete.
  *
  * MORPH-SPEC 3.0 - Phase A: Active Validation Pipeline
  */
@@ -10,16 +10,10 @@
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import chalk from 'chalk';
-import { loadState } from '../../core/state/state-manager.js';
 import { getAbsoluteOutputPath, resolveContractsOutputType } from '../../core/paths/output-schema.js';
 import { getStackProfile } from '../stack/stack-profile.js';
 import { aggregateScores, loadRubric } from './score-aggregator.js';
 
-/** Validators that only make sense for .NET projects. */
-const DOTNET_ONLY_VALIDATORS = new Set([
-  'architecture', 'packages', 'contract-compliance'
-]);
-
 /**
  * Heavy validators skipped in 'light' mode (checkpoint-only).
  * Light mode runs only spec, content, and stack-specific lightweight validators.
@@ -29,31 +23,6 @@ const HEAVY_VALIDATORS = new Set([
   'css', 'design-system'
 ]);
 
-/**
- * Load agent → validators map from agents.json (data-driven)
- * @param {string} projectPath - Root path of the project
- * @returns {Object} Map of agent IDs to validator arrays
- */
-function loadAgentValidatorMap(projectPath) {
-  try {
-    const agentsPath = join(projectPath, '.morph/framework/agents.json');
-    const agentsConfig = JSON.parse(readFileSync(agentsPath, 'utf8'));
-
-    const map = {};
-    Object.entries(agentsConfig.agents || {}).forEach(([agentId, agent]) => {
-      if (!agentId.startsWith('_comment') && agent.validators && agent.validators.length > 0) {
-        map[agentId] = agent.validators;
-      }
-    });
-
-    return map;
-  } catch (err) {
-    console.warn(chalk.yellow('⚠️  Failed to load agents.json - no validators will run'));
-    console.warn(chalk.gray(`   Run 'morph-spec init' to set up MORPH-SPEC configuration`));
-    return {}; // Empty map = honest failure
-  }
-}
-
 /**
  * Run all relevant validators for a feature
  *
@@ -61,7 +30,7 @@ function loadAgentValidatorMap(projectPath) {
  * @param {string} featureName - Feature name from state.json
  * @param {Object} options - Options
  * @param {boolean} options.verbose - Show detailed output
- * @param {string[]} options.validators - Specific validators to run (overrides agent-based detection)
+ * @param {string[]} options.validators - Specific validators to run (overrides stack-based detection)
  * @returns {Object} { passed, errors, warnings, issues, summary }
  */
 export async function runValidation(projectPath, featureName, options = {}) {
@@ -81,7 +50,7 @@ export async function runValidation(projectPath, featureName, options = {}) {
   };
 
   // Determine which validators to run
-  const validatorIds = options.validators || detectValidators(featureName, projectPath);
+  const validatorIds = options.validators || detectValidators(projectPath);
 
   // Filter by mode: 'light' skips heavy validators, 'full' (default) runs all
   const mode = options.mode || 'full';
@@ -98,17 +67,8 @@ export async function runValidation(projectPath, featureName, options = {}) {
   validatorIds.push(...constraints.enabledValidators);
 
   if (validatorIds.length === 0) {
-    // Distinguish: no agents vs. no validators mapped
-    const state = loadState(false);
-    const activeAgents = state?.features?.[featureName]?.activeAgents || [];
-    if (activeAgents.length === 0) {
-      result.summary = 'No validators ran — feature has no active agents';
-      console.log(chalk.gray('\n  ℹ️  No validators configured (no active agents in state.json)'));
-      console.log(chalk.gray('     Add agents: morph-spec state add-agent ' + featureName + ' <agent-id>'));
-    } else {
-      result.summary = `No validators mapped for active agents: ${activeAgents.join(', ')}`;
-      console.log(chalk.gray(`\n  ℹ️  Agents [${activeAgents.join(', ')}] have no validators in agents.json`));
-    }
+    result.summary = 'No validators ran — no validators configured for this stack';
+    console.log(chalk.gray('\n  ℹ️  No validators configured for this stack'));
     result._skipReason = result.summary;
     return result;
   }
@@ -124,7 +84,10 @@ export async function runValidation(projectPath, featureName, options = {}) {
     const _profileForContracts = getStackProfile(projectPath);
     const contractsType = resolveContractsOutputType(_profileForContracts.stack);
     const contractsPath = getAbsoluteOutputPath(projectPath, featureName, contractsType);
-    if (existsSync(contractsPath) && !_profileForContracts.isNextjs) {
+    // Positive check on isDotnet (contract-compliance is a VSA/.NET concern) —
+    // NOT `!isNextjs`, which used to wrongly suppress it for a compound
+    // "dotnet-nextjs" stack that has a .NET backend but is ALSO isNextjs.
+    if (existsSync(contractsPath) && _profileForContracts.isDotnet) {
       validatorIds.push('contract-compliance');
     }
   }
@@ -188,37 +151,13 @@ export async function runValidation(projectPath, featureName, options = {}) {
 }
 
 /**
- * Detect which validators to run based on feature's active agents
- * @param {string} featureName - Feature name
+ * Detect which validators to run, driven by the project's stack profile.
  * @param {string} projectPath - Project root path (default: current directory)
  * @returns {string[]} Array of validator IDs to run
  */
-function detectValidators(featureName, projectPath = '.') {
+function detectValidators(projectPath = '.') {
   const profile = getStackProfile(projectPath);
-  const state = loadState(false);
-
-  if (!state || !state.features[featureName]) {
-    return [...profile.defaultValidators]; // stack-aware defaults
-  }
-
-  const feature = state.features[featureName];
-  const agents = feature.activeAgents || [];
-  const validatorSet = new Set(profile.defaultValidators); // stack defaults first
-
-  const agentValidatorMap = loadAgentValidatorMap(projectPath);
-  for (const agentId of agents) {
-    const validators = agentValidatorMap[agentId] || [];
-    validators.forEach(v => validatorSet.add(v));
-  }
-
-  // Filter out .NET-only validators for non-.NET projects
-  if (!profile.isDotnet) {
-    for (const v of DOTNET_ONLY_VALIDATORS) {
-      validatorSet.delete(v);
-    }
-  }
-
-  return Array.from(validatorSet);
+  return [...profile.defaultValidators];
 }
 
 /**

package/src/utils/hooks-installer.js

@@ -15,7 +15,7 @@ import { homedir } from 'os';
 import { execSync } from 'child_process';
 
 /** Current hooks schema version — bump when hook definitions change */
-const HOOKS_VERSION = '3.3.0';
+const HOOKS_VERSION = '3.4.0';
 
 /** Marker for old dispatch.js (v1) */
 const OLD_DISPATCH_COMMAND = 'node framework/hooks/agent-teams/dispatch.js';
@@ -165,13 +165,37 @@ const MORPH_HOOKS = [
     ]
   },
 
-  // === PostToolUse: All — loop detection ===
+  // === PostToolUse: All — telemetry capture (silent) + loop detection ===
+  // telemetry-log is the single generic vantage point of an NLH: it appends
+  // every tool call (skill, sub-agent dispatch, knowledge-base read, …) to
+  // .morph/logs/events.jsonl. Silent and fail-open — never blocks, never
+  // injects. `morph-spec telemetry` reads the stream back.
   {
     event: 'PostToolUse',
     matcher: null,
+    hooks: [
+      {
+        type: 'command',
+        command: 'node framework/hooks/claude-code/core/telemetry-log.js',
+        timeout: 5000
+      },
+      {
+        type: 'command',
+        command: 'node framework/hooks/claude-code/core/loop-detect.js',
+        timeout: 5000
+      }
+    ]
+  },
+
+  // === UserPromptSubmit — telemetry capture of the user's prompt (silent) ===
+  // The only vantage point on the user's own prompt; completes the execution
+  // path alongside sub-agent prompts captured on PostToolUse.
+  {
+    event: 'UserPromptSubmit',
+    matcher: null,
     hooks: [{
       type: 'command',
-      command: 'node framework/hooks/claude-code/core/loop-detect.js',
+      command: 'node framework/hooks/claude-code/core/telemetry-log.js',
       timeout: 5000
     }]
   },