@polymorphism-tech/morph-spec 4.8.14 → 4.8.16

package/src/lib/standards/digest-builder.js

@@ -0,0 +1,231 @@
+/**
+ * Standard Digest Builder
+ *
+ * Composes agent briefings from STANDARDS.json digests.
+ * Reduces context per agent from ~2000-8000 tokens (file reads)
+ * to ~400-600 tokens (digest inline).
+ *
+ * Usage:
+ *   buildAgentBriefing(agentId, phase) → string
+ *   Injected into dispatch taskPrompt as "\n\nConstraints:\n" + briefing
+ *
+ * Standards refs in agents.json support two formats:
+ *   Legacy: "core/coding.md"   (treated as scope:'all', priority:'required')
+ *   Scoped: { id, scope, priority, anchor }
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const AGENTS_JSON_PATH = join(__dirname, '../../../framework/agents.json');
+const STANDARDS_JSON_PATH = join(__dirname, '../../../framework/standards/STANDARDS.json');
+
+let _agentsCache = null;
+let _standardsCache = null;
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Loaders
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** Load and cache agents.json */
+function loadAgents() {
+  if (_agentsCache) return _agentsCache;
+  if (!existsSync(AGENTS_JSON_PATH)) return { agents: {} };
+  try {
+    _agentsCache = JSON.parse(readFileSync(AGENTS_JSON_PATH, 'utf8'));
+    return _agentsCache;
+  } catch {
+    return { agents: {} };
+  }
+}
+
+/** Load STANDARDS.json and build path/id lookup maps (module-level cache) */
+function loadStandards() {
+  if (_standardsCache) return _standardsCache;
+  if (!existsSync(STANDARDS_JSON_PATH)) {
+    _standardsCache = { byPath: new Map(), byId: new Map() };
+    return _standardsCache;
+  }
+  try {
+    const raw = JSON.parse(readFileSync(STANDARDS_JSON_PATH, 'utf8'));
+    const byPath = new Map();
+    const byId = new Map();
+    for (const entry of raw.standards || []) {
+      byPath.set(entry.path, entry);
+      byId.set(entry.id, entry);
+    }
+    _standardsCache = { byPath, byId };
+    return _standardsCache;
+  } catch {
+    _standardsCache = { byPath: new Map(), byId: new Map() };
+    return _standardsCache;
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Normalize a standards reference to canonical shape.
+ * Supports legacy string format and new scoped object format.
+ *
+ * @param {string|Object} ref
+ * @returns {{ id?: string, path?: string, scope: string, priority: string, anchor?: string }}
+ */
+function normalizeRef(ref) {
+  if (typeof ref === 'string') {
+    return { path: ref, scope: 'all', priority: 'required' };
+  }
+  return {
+    id: ref.id,
+    path: ref.path,
+    scope: ref.scope || 'all',
+    priority: ref.priority || 'required',
+    anchor: ref.anchor,
+  };
+}
+
+/**
+ * Resolve a normalized ref to a STANDARDS.json entry.
+ * Tries id lookup first, then exact path, then suffix match for short paths.
+ *
+ * @param {{ id?: string, path?: string }} ref
+ * @param {{ byPath: Map, byId: Map }} standards
+ * @returns {Object|null}
+ */
+function resolveEntry(ref, standards) {
+  if (ref.id) {
+    const entry = standards.byId.get(ref.id);
+    if (entry) return entry;
+  }
+  if (ref.path) {
+    const entry = standards.byPath.get(ref.path);
+    if (entry) return entry;
+
+    // Some agents use short paths like "azure.md" — try suffix match
+    for (const [, e] of standards.byPath) {
+      if (e.path.endsWith('/' + ref.path)) return e;
+    }
+  }
+  return null;
+}
+
+/**
+ * Format a single standards entry as a briefing line.
+ *
+ * priority='required' with digest → inline digest text
+ * priority='reference' → path + optional anchor only
+ * no digest → path reference fallback
+ *
+ * @param {Object} entry - STANDARDS.json entry
+ * @param {string} priority - 'required' | 'reference'
+ * @param {string} [anchor] - specific anchor key from entry.anchors
+ * @returns {string}
+ */
+function formatBriefingLine(entry, priority, anchor) {
+  const anchorFrag = anchor && entry.anchors?.[anchor] ? entry.anchors[anchor] : '';
+
+  if (priority === 'required' && entry.digest) {
+    const ref = anchorFrag ? ` (ref: ${entry.path}${anchorFrag})` : '';
+    return `[${entry.name.toUpperCase()}] ${entry.digest}${ref}`;
+  }
+
+  if (priority === 'reference') {
+    return `[REF: ${entry.path}${anchorFrag}]`;
+  }
+
+  // No digest — inject path reference as fallback
+  return `[REF: ${entry.path}${anchorFrag}]`;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Public API
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Build an agent briefing string for injection into taskPrompt.
+ * Returns empty string when agent not found, has no standards, or all refs
+ * are filtered by scope.
+ *
+ * @param {string} agentId - Agent ID from agents.json
+ * @param {string} phase - Current phase (design|tasks|implement)
+ * @returns {string} Formatted briefing or ''
+ */
+export function buildAgentBriefing(agentId, phase) {
+  const agents = loadAgents();
+  const agentData = agents.agents?.[agentId];
+  if (!agentData) return '';
+
+  const standardsRefs = agentData.standards || [];
+  if (standardsRefs.length === 0) return '';
+
+  const standards = loadStandards();
+  const lines = [];
+
+  for (const rawRef of standardsRefs) {
+    const ref = normalizeRef(rawRef);
+
+    // Scope filtering: skip refs scoped to a different phase
+    if (ref.scope !== 'all' && ref.scope !== phase) continue;
+
+    const entry = resolveEntry(ref, standards);
+    if (!entry) {
+      // No entry found in registry — emit a path reference as fallback
+      const path = ref.path || ref.id;
+      if (path) lines.push(`[REF: ${path}]`);
+      continue;
+    }
+
+    const line = formatBriefingLine(entry, ref.priority, ref.anchor);
+    if (line) lines.push(line);
+  }
+
+  return lines.length > 0 ? lines.join('\n') : '';
+}
+
+/**
+ * Build a read-only validation task prompt for Tier-4 validator agents.
+ * Uses hook_behavior.validates[] from agents.json.
+ *
+ * @param {string} agentId - Agent ID (must be tier 4 with hook_behavior)
+ * @param {string} [taskId] - Optional task ID being validated
+ * @returns {string} Validator task prompt or ''
+ */
+export function buildValidatorPrompt(agentId, taskId) {
+  const agents = loadAgents();
+  const agentData = agents.agents?.[agentId];
+  if (!agentData?.hook_behavior) return '';
+
+  const validates = agentData.hook_behavior.validates || [];
+  const severity = agentData.hook_behavior.severity || 'error';
+  const blocksOnFail = agentData.hook_behavior.blocks_on_fail ?? true;
+  const taskSuffix = taskId ? ` for task ${taskId}` : '';
+
+  const lines = [
+    `You are ${agentData.title || agentId} (Tier 4 Validator). Mode: READ-ONLY validation${taskSuffix}.`,
+    `DO NOT edit any files. Review the current implementation for the following violations:`,
+    ``,
+    `Checks (severity: ${severity}):`,
+    ...validates.map(v => `  - ${v}`),
+    ``,
+    `Output a single JSON line: { "passed": boolean, "issues": [{ "file": "path/to/file", "line": 0, "message": "description", "rule": "rule-name" }] }`,
+    blocksOnFail
+      ? `BLOCKING: if any issues found, implementation must be fixed before task can complete.`
+      : `NON-BLOCKING: issues are warnings only — task completion is not blocked.`,
+  ];
+
+  return lines.join('\n');
+}
+
+/**
+ * Invalidate module-level caches.
+ * Used in tests to ensure a fresh load of agents.json / STANDARDS.json.
+ */
+export function clearCache() {
+  _agentsCache = null;
+  _standardsCache = null;
+}

package/src/lib/validators/blazor/blazor-concurrency-analyzer.js

@@ -7,6 +7,8 @@
  * @module blazor-concurrency-analyzer
  */
 
+import { readFileSync } from 'fs';
+import { glob } from 'glob';
 import { countIssues } from '../shared/index.js';
 
 /**
@@ -174,6 +176,9 @@ export function checkScopedInSingleton(content, filePath) {
   const issues = [];
   const lines = content.split('\n');
 
+  // Type guard: filePath must be a string (validation-runner may pass options object)
+  if (typeof filePath !== 'string') return [];
+
   // Check if class might be a singleton (common naming patterns)
   const isSingletonCandidate =
     filePath.includes('BackgroundService') ||
@@ -267,8 +272,42 @@ export function analyzeConcurrency(content, filePath) {
 }
 
 
+/**
+ * Project-level concurrency validator. Scans all .cs files in projectPath.
+ * Follows the same interface as other project-level validators (validateNextComponentFiles, etc.)
+ *
+ * @param {string} projectPath - Project root path
+ * @param {Object} [_options]
+ * @returns {Promise<{errors: number, warnings: number, issues: Array}>}
+ */
+export async function validateConcurrencyFiles(projectPath, _options = {}) {
+  const result = { errors: 0, warnings: 0, issues: [] };
+  const pattern = projectPath.replace(/\\/g, '/') + '/**/*.cs';
+  const files = await glob(pattern, { ignore: ['**/node_modules/**', '**/obj/**', '**/bin/**'] });
+
+  for (const filePath of files) {
+    const content = readFileSync(filePath, 'utf8');
+    const relPath = filePath.replace(projectPath.replace(/\\/g, '/') + '/', '');
+    const fileIssues = analyzeConcurrency(content, relPath);
+    for (const issue of fileIssues) {
+      result.issues.push({
+        level: issue.type,
+        message: issue.message,
+        file: issue.file,
+        line: issue.line,
+        solution: issue.suggestion,
+      });
+      if (issue.type === 'error') result.errors++;
+      else result.warnings++;
+    }
+  }
+
+  return result;
+}
+
 export default {
   analyzeConcurrency,
+  validateConcurrencyFiles,
   checkScopedDbContextInBackground,
   checkHangfireWithScopedServices,
   checkScopedInSingleton,

package/src/lib/validators/nextjs/next-component-validator.js

@@ -86,7 +86,9 @@ export function validateNextComponent(content, filePath) {
   }
 
   // Check 2: hooks used without use client
+  // .ts files (custom hooks, utilities) never render JSX — skip this check
   if (!hasUseClient) {
+    if (!filePath.endsWith('.tsx')) return issues;
     const usedHooks = CLIENT_HOOKS.filter(hook => new RegExp(`\\b${hook}\\b`).test(content));
     if (usedHooks.length > 0) {
       issues.push({

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

@@ -202,8 +202,8 @@ async function runSingleValidator(validatorId, projectPath, featureName, options
     }
 
     case 'blazor-concurrency': {
-      const { analyzeConcurrency } = await import('./blazor/blazor-concurrency-analyzer.js');
-      return await analyzeConcurrency(projectPath, options);
+      const { validateConcurrencyFiles } = await import('./blazor/blazor-concurrency-analyzer.js');
+      return await validateConcurrencyFiles(projectPath, options);
     }
 
     case 'blazor-state': {

package/src/utils/file-copier.js

@@ -136,6 +136,7 @@ export async function updateGitignore(projectPath) {
     '# MORPH-SPEC',
     '.morph/framework/',
     '.morph/memory/',
+    '.morph/plans/',
     '.morph/analytics/',
     '.claude/commands/',
     '.claude/rules/',
@@ -143,6 +144,7 @@ export async function updateGitignore(projectPath) {
     '.claude/agents/',
     '.claude/CLAUDE.md',
     '.claude/settings.local.json',
+    '.mcp.json',
     ''
   ];
 

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 = '2.5.1';
+const HOOKS_VERSION = '2.6.0';
 
 /** Marker for old dispatch.js (v1) */
 const OLD_DISPATCH_COMMAND = 'node framework/hooks/agent-teams/dispatch.js';
@@ -67,10 +67,16 @@ const MORPH_HOOKS = [
   {
     event: 'UserPromptSubmit',
     matcher: null,
-    hooks: [{
-      type: 'command',
-      command: 'node framework/hooks/claude-code/user-prompt/enrich-prompt.js'
-    }]
+    hooks: [
+      {
+        type: 'command',
+        command: 'node framework/hooks/claude-code/user-prompt/enrich-prompt.js'
+      },
+      {
+        type: 'command',
+        command: 'node framework/hooks/claude-code/user-prompt/set-terminal-title.js'
+      }
+    ]
   },
 
   // === PreToolUse: Write|Edit ===
@@ -155,6 +161,20 @@ Otherwise respond: {"ok": true}`
       type: 'command',
       command: 'node framework/hooks/claude-code/notification/approval-reminder.js'
     }]
+  },
+
+  // === TeammateIdle ===
+  // Fires when an Agent Team teammate finishes and is about to go idle.
+  // Exit 2 = send feedback to teammate to continue working (validation failed).
+  // Exit 0 = teammate may become idle (validation passed).
+  // Requires CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 (set in env above).
+  {
+    event: 'TeammateIdle',
+    matcher: null,
+    hooks: [{
+      type: 'command',
+      command: 'node framework/hooks/claude-code/teammate-idle/teammate-idle.js'
+    }]
   }
 ];
 
@@ -241,8 +261,12 @@ export async function installClaudeHooks(targetPath) {
   // JSON Schema for IDE auto-complete and validation
   settings['$schema'] = 'https://json.schemastore.org/claude-code-settings.json';
 
-  // Environment variables — always set MORPH_SPEC_ACTIVE, preserve user additions
-  settings.env = { ...settings.env, MORPH_SPEC_ACTIVE: 'true' };
+  // Environment variables — always set MORPH_SPEC_ACTIVE + Agent Teams flag, preserve user additions
+  settings.env = {
+    ...settings.env,
+    MORPH_SPEC_ACTIVE: 'true',
+    CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: '1',
+  };
 
   // Attribution — only set if not already customized by user
   if (!settings.attribution) {