@polymorphism-tech/morph-spec 8.2.0 → 8.3.0

package/src/commands/project/worktree.js

@@ -145,6 +145,38 @@ function getDateSuffix() {
 
 // ── Infrastructure linking ───────────────────────────────────────────────────
 
+/**
+ * The infra directories morph itself links into a worktree — the ONLY ones
+ * `setupInfraLinks`/`worktreeLinkCommand --all`/`unlinkWorktreeInfraLinks` treat
+ * as KNOWN, and therefore the only ones `finish` may auto-remove via the
+ * already-proven-safe unlink mechanism (never by widening the reparse-point
+ * scan — see `findReparsePoints`).
+ *
+ * Always: `node_modules`, `.claude`. Conditionally: `.morph/framework` (client
+ * projects only) and `{project.frontendPath}/node_modules` — a monorepo
+ * frontend (e.g. a Next.js app under `apps/catalog-admin`) commonly has its OWN
+ * node_modules, a separate `npm install` from the root's, invisible to a static
+ * list. Fail-open: a missing/unreadable config.json just means no frontendPath.
+ *
+ * @param {string} mainCwd - Absolute path to the main project root
+ * @returns {string[]} relative paths, root-first
+ */
+function resolveInfraLinkDirs(mainCwd) {
+  const dirs = ['node_modules', '.claude'];
+  if (existsSync(join(mainCwd, '.morph', 'framework'))) {
+    dirs.push(join('.morph', 'framework'));
+  }
+  try {
+    const configPath = join(mainCwd, '.morph', 'config', 'config.json');
+    if (existsSync(configPath)) {
+      const config = JSON.parse(readFileSync(configPath, 'utf8'));
+      const frontendPath = config?.project?.frontendPath;
+      if (frontendPath) dirs.push(join(frontendPath, 'node_modules'));
+    }
+  } catch { /* fail-open — no frontendPath to add */ }
+  return dirs;
+}
+
 /**
  * Create junctions in the worktree for shared infrastructure directories
  * (node_modules/, .claude/, .morph/framework/).
@@ -169,16 +201,9 @@ export function setupInfraLinks(worktreePath, mainCwd, opts = {}) {
   const mainAbs = resolve(mainCwd);
   const wtAbs = resolve(worktreePath);
 
-  let dirLinks;
-  if (Array.isArray(opts.dirs) && opts.dirs.length) {
-    dirLinks = opts.dirs;
-  } else {
-    dirLinks = ['node_modules', '.claude'];
-    // .morph/framework/ — client projects (in framework repo, framework/ is tracked)
-    if (existsSync(join(mainAbs, '.morph', 'framework'))) {
-      dirLinks.push(join('.morph', 'framework'));
-    }
-  }
+  const dirLinks = (Array.isArray(opts.dirs) && opts.dirs.length)
+    ? opts.dirs
+    : resolveInfraLinkDirs(mainAbs);
 
   for (const rel of dirLinks) {
     const target = join(mainAbs, rel);
@@ -530,7 +555,7 @@ export function worktreeLinkCommand(options = {}) {
   }
 
   const dirs = options.all
-    ? ['node_modules', '.claude', join('.morph', 'framework')]
+    ? resolveInfraLinkDirs(root)
     : ['node_modules'];
 
   const alreadyPresent = {};
@@ -624,12 +649,10 @@ function findWorktreeForFeature(feature, root) {
   return { path: match.path, branch: actual, expectedBranch };
 }
 
-/** The infra paths `setupInfraLinks` junctions into a worktree. */
-const INFRA_LINK_RELS = ['node_modules', '.claude', join('.morph', 'framework')];
-
 /**
  * Drop the infra junctions a worktree carries (`node_modules`, `.claude`,
- * `.morph/framework`) WITHOUT following them.
+ * `.morph/framework`, and the `project.frontendPath` node_modules if
+ * configured) WITHOUT following them.
  *
  * CRITICAL — this is what keeps `worktree finish` from destroying the project.
  * `git worktree remove` refuses a worktree still holding these ("contains
@@ -646,12 +669,19 @@ const INFRA_LINK_RELS = ['node_modules', '.claude', join('.morph', 'framework')]
  * target's contents, and `rmdirSync` fails on a real non-empty directory — the
  * safety that stops this from ever deleting genuine files.
  *
+ * This is deliberately narrow to the KNOWN inventory from `resolveInfraLinkDirs`
+ * — never widened to auto-remove any reparse point `findReparsePoints` might
+ * discover elsewhere. An unknown/nested link (npm link, npm workspaces) must
+ * still decline the removal; see the CANARY tests pinning that in worktree.test.js.
+ *
  * @param {string} worktreePath
+ * @param {string} mainCwd - Absolute path to the main project root, to resolve
+ *   `project.frontendPath` from config.json
  * @returns {string[]} relative paths actually unlinked
  */
-export function unlinkWorktreeInfraLinks(worktreePath) {
+export function unlinkWorktreeInfraLinks(worktreePath, mainCwd) {
   const removed = [];
-  for (const rel of INFRA_LINK_RELS) {
+  for (const rel of resolveInfraLinkDirs(mainCwd)) {
     const p = join(worktreePath, rel);
     let st;
     try {
@@ -746,9 +776,60 @@ function findReparsePoints(dir, base = dir, acc = { points: [], unprovable: [] }
  */
 const IGNORED_SHIELDABLE_PREFIXES = ['.morph/'];
 
+/**
+ * Well-known, regenerable build artifacts — `bin/`, `obj/` (dotnet), a real
+ * `node_modules` left behind outside the setup-created junction, and
+ * `*.tsbuildinfo` (tsc incremental cache). These are the everyday leftovers of
+ * running a build/test cycle inside a worktree, not user data: they are fully
+ * reproducible from source, and requiring `--discard-ignored` for every finish
+ * that ever ran a build turns the flag from "explicit consent for a real risk"
+ * into a rubber stamp nobody reads anymore. Auto-discarding them (like any
+ * `discarded` entry, WITHOUT a backup — see the note below) is safe precisely
+ * because "regenerable" is a stronger guarantee than "backed up".
+ *
+ * Deliberately narrow — do NOT add speculative patterns (`dist/`, `.next/`)
+ * beyond what's proven to be pure noise; anything else stays in `blocking` by
+ * default, requiring the explicit `--discard-ignored` consent.
+ *
+ * @param {string} p - forward-slash relative path from `git status --ignored`
+ */
+/**
+ * Whether a dirty root-side path is EXACTLY a sibling feature's live worktree
+ * registration — see the call site (Validation 3 in worktreeFinishCommand)
+ * for why this is safe to exempt from the whole-root clean gate rather than a
+ * widened hole.
+ *
+ * PROVES it rather than assuming: the path must be exactly that sibling's
+ * `feature.json`, must parse, and its `worktree.path` must point at a
+ * currently-existing directory. A parse failure, a missing registration, or a
+ * STALE pointer (worktree already removed) is NOT exempted.
+ *
+ * @param {string} relPath - forward-slash path relative to `root`
+ * @param {string} root - absolute path to the primary root
+ * @param {string} feature - the feature THIS finish is acting on (never exempted — its own scope is the shed's job)
+ */
+function isLiveSiblingWorktreeRegistration(relPath, root, feature) {
+  const m = relPath.match(/^\.morph\/features\/([^/]+)\/feature\.json$/);
+  if (!m || m[1] === feature) return false;
+  try {
+    const fj = JSON.parse(readFileSync(join(root, relPath), 'utf8'));
+    const wtPath = fj?.worktree?.path;
+    return typeof wtPath === 'string' && wtPath.length > 0 && existsSync(wtPath);
+  } catch {
+    return false;
+  }
+}
+
+function isDisposableBuildArtifact(p) {
+  if (/\.tsbuildinfo$/.test(p)) return true;
+  const segments = p.split('/').filter(Boolean);
+  return segments.some((s) => s === 'bin' || s === 'obj' || s === 'node_modules');
+}
+
 /**
  * Split the worktree's GITIGNORED leftovers into what this command may remove
- * (morph's own, after a backup) and what it must refuse to destroy.
+ * (morph's own, after a backup, or a known disposable build artifact, without
+ * one) and what it must refuse to destroy.
  *
  * Why this exists: `git worktree remove` deletes gitignored files outright, and
  * the clean-check that gates it uses `git status --porcelain`, which omits them
@@ -762,34 +843,46 @@ const IGNORED_SHIELDABLE_PREFIXES = ['.morph/'];
  *
  * @param {string} worktreePath
  * @param {{ discardIgnored?: boolean }} options
- * @returns {{ shieldable: string[], blocking: string[] }}
+ * @returns {{ shieldable: string[], blocking: string[], discarded: string[] }}
  */
 function classifyIgnoredLeftovers(worktreePath, options = {}) {
   let out;
   try {
     // `-z` + execFile: NUL-delimited, no shell, no C-style quoting to undo —
     // paths with spaces or non-ASCII (a pt-BR codebase has both) stay intact.
-    out = execFileSync('git', ['status', '--porcelain', '--ignored', '-z'], { cwd: worktreePath, stdio: 'pipe' }).toString();
+    // `=matching` (not the traditional default): an ignored directory whose own
+    // name matches no pattern — e.g. `MyProj/`, ignored only because EVERYTHING
+    // inside it (`bin/`, `obj/`) does — otherwise collapses into one opaque
+    // `MyProj/` entry, hiding the actual disposable-artifact names from
+    // isDisposableBuildArtifact. A directory that IS itself the matched pattern
+    // (`node_modules/`) still reports as one entry either way — verified
+    // empirically, not assumed.
+    out = execFileSync('git', ['status', '--porcelain', '--ignored=matching', '-z'], { cwd: worktreePath, stdio: 'pipe' }).toString();
   } catch {
-    return { shieldable: [], blocking: ['<git status --ignored falhou — não foi possível enumerar o que seria destruído>'] };
+    return { shieldable: [], blocking: ['<git status --ignored falhou — não foi possível enumerar o que seria destruído>'], discarded: [] };
   }
 
   const shieldable = [];
-  const blocking = [];
+  const blockingRest = [];
+  const disposable = [];
   for (const record of out.split('\0')) {
     if (!record || record.length < 4) continue;
     if (record.slice(0, 2) !== '!!') continue; // only ignored entries; the rest is the clean-check's job
     const p = record.slice(3).replace(/\\/g, '/');
     if (IGNORED_SHIELDABLE_PREFIXES.some((prefix) => p.startsWith(prefix))) shieldable.push(p);
-    else blocking.push(p);
+    else if (isDisposableBuildArtifact(p)) disposable.push(p);
+    else blockingRest.push(p);
   }
-  // Explicit consent clears the block — but the list is NOT thrown away. These
-  // are the files that exist nowhere else, and they are the ones about to die;
-  // reporting them is the least this can do. (Backing them up instead is not an
-  // option: this bucket is where `node_modules`/`dist`/`.next` land, so a copy
-  // is unbounded. The user declared them disposable — they still get told.)
-  if (options.discardIgnored) return { shieldable, blocking: [], discarded: blocking };
-  return { shieldable, blocking, discarded: [] };
+  // Explicit consent clears the rest of the block too — but the list is NOT
+  // thrown away. These are the files that exist nowhere else, and they are the
+  // ones about to die; reporting them is the least this can do. (Backing them
+  // up instead is not an option: this bucket is where arbitrarily large
+  // leftovers land, so a copy is unbounded. The user declared them
+  // disposable — they still get told.)
+  if (options.discardIgnored) return { shieldable, blocking: [], discarded: [...disposable, ...blockingRest] };
+  // Known build artifacts are discarded by default, no flag required — they
+  // are reproducible from source, unlike anything else in `blockingRest`.
+  return { shieldable, blocking: blockingRest, discarded: disposable };
 }
 
 /**
@@ -1015,15 +1108,34 @@ export async function worktreeFinishCommand(feature, options = {}) {
     }
     : {};
 
-  // Validation 3: primary root must be clean.
-  let rootStatus;
+  // Validation 3: primary root must be clean — except a SIBLING feature's own
+  // LIVE worktree registration (see isLiveSiblingWorktreeRegistration). That
+  // artifact is how `runWorktreeSetup`/`create --worktree` are DESIGNED to
+  // leave the root for that sibling's entire life (decidePersistence in
+  // verify.js and the anti-dupe guard above both read the root's copy for
+  // `.worktree.path`), so refusing THIS feature's finish over it would block
+  // every OTHER feature for as long as any sibling stays open in its own
+  // worktree — the exact "orphaned scaffold collides with finish" friction
+  // from real multi-feature use. Anything else is still unexplained dirt and
+  // still blocks, fail-closed, exactly as before.
+  let rootStatusRaw;
   try {
-    rootStatus = execFileSync('git', ['status', '--porcelain'], { cwd: root, stdio: 'pipe' }).toString();
+    // `--untracked-files=all`, not the default `normal`: the default collapses
+    // an entirely-untracked directory into one entry (e.g. `.morph/features/
+    // sibling-feat/`, verified empirically) — which would never match the
+    // exact `.../feature.json` path isLiveSiblingWorktreeRegistration expects,
+    // silently defeating the exemption for the very shape it exists to allow.
+    rootStatusRaw = execFileSync('git', ['status', '--porcelain', '--untracked-files=all', '-z'], { cwd: root, stdio: 'pipe' }).toString();
   } catch (err) {
     console.log(JSON.stringify({ finished: false, error: 'primary-root-status-failed', detail: (err.message || '').slice(0, 200), feature, ...backupNote }));
     process.exit(1);
   }
-  if (rootStatus.trim() !== '') {
+  const unexplainedDirt = rootStatusRaw.split('\0').filter((record) => {
+    if (!record || record.length < 4) return false;
+    const p = record.slice(3).replace(/\\/g, '/');
+    return !isLiveSiblingWorktreeRegistration(p, root, feature);
+  });
+  if (unexplainedDirt.length) {
     console.log(JSON.stringify({
       finished: false,
       error: 'primary-root-dirty',
@@ -1075,7 +1187,7 @@ export async function worktreeFinishCommand(feature, options = {}) {
   // Both gates below therefore PROVE-or-DECLINE. Declining costs a stale
   // directory the user can delete in one command; being wrong costs data that
   // exists nowhere else.
-  unlinkWorktreeInfraLinks(worktreePath);
+  unlinkWorktreeInfraLinks(worktreePath, root);
 
   const scan = findReparsePoints(worktreePath);
   const ignored = classifyIgnoredLeftovers(worktreePath, options);
@@ -1202,7 +1314,9 @@ export async function worktreeFinishCommand(feature, options = {}) {
     ...(worktreeRemoved && ignored.discarded.length
       ? {
         discardedIgnored: ignored.discarded,
-        discardedNote: `--discard-ignored: os caminhos acima eram gitignored, existiam só no worktree e foram DESTRUÍDOS sem backup (não são copiados por poderem ser arbitrariamente grandes)`,
+        discardedNote: options.discardIgnored
+          ? `--discard-ignored: os caminhos acima eram gitignored, existiam só no worktree e foram DESTRUÍDOS sem backup (não são copiados por poderem ser arbitrariamente grandes)`
+          : `artefatos de build reconhecidos (bin/, obj/, node_modules/, *.tsbuildinfo) — descartados por padrão, sem backup (regeneráveis a partir do source)`,
       }
       : {}),
     ...(worktreeRemoved

package/src/commands/state/score.js

@@ -39,9 +39,20 @@ export async function scoreCommand(featureName, taskId, scoreArg, options = {})
 
     let dimensions;
     if (options.dims) {
-      const parts = String(options.dims).split(',').map(s => s.trim());
+      // Commander captures --dims as variadic (`<dims...>`), so an UNQUOTED
+      // comma list typed in PowerShell — `--dims 9.5,9,9,9` — that arrives as
+      // 4 separate argv tokens (confirmed: Commander binds only the first
+      // token to a non-variadic option and silently drops the rest) is not
+      // lost. Accept either shape: one comma-joined string (the documented,
+      // quoted form) or N separate tokens — split on both separators so a
+      // mix of the two never matters either.
+      const raw = Array.isArray(options.dims) ? options.dims.join(' ') : String(options.dims);
+      const parts = raw.split(/[,\s]+/).filter(Boolean);
       if (parts.length !== DIM_KEYS.length) {
-        console.error(chalk.red(`\n❌ --dims expects ${DIM_KEYS.length} comma-separated values in order a,c,q,t (architecture,contracts,code-quality,test-coverage)\n`));
+        console.error(chalk.red(
+          `\n❌ --dims expects ${DIM_KEYS.length} values in order a,c,q,t (architecture,contracts,code-quality,test-coverage) — got ${parts.length} (${JSON.stringify(parts)}).\n` +
+          `   Quote the value under PowerShell to keep it as one argument: --dims "9.5,9,9,9"\n`
+        ));
         process.exit(1);
       }
       dimensions = {};

package/src/commands/tasks/dag.js

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import { existsSync } from 'fs';
 import { join } from 'path';
-import { parseTasksJson } from '../../lib/tasks/tasks-json-parser.js';
+import { parseTasksJsonLenient } from '../../lib/tasks/tasks-json-parser.js';
 import { planDispatch } from '../../lib/tasks/dispatch-planner.js';
 import { renderMermaidFlowchart } from '../../lib/tasks/mermaid-renderer.js';
 
@@ -24,8 +24,16 @@ export async function dagCommand(featureName, options = {}) {
       process.exit(1);
     }
 
-    // parseTasksJson validates the schema and throws with the error list.
-    const data = await parseTasksJson(tasksPath);
+    // parseTasksJsonLenient validates the schema and throws with the error
+    // list, but defaults a missing `version` (legacy plans predating the
+    // field) instead of failing — the DAG analysis doesn't depend on it.
+    const { data, versionDefaulted } = await parseTasksJsonLenient(tasksPath);
+    if (versionDefaulted) {
+      console.error(chalk.yellow(
+        `⚠ tasks.json has no 'version' field — defaulting to "1.0" for this analysis.\n` +
+        `  Consider adding it back explicitly (safe: protect-spec-files allows backfilling it).`
+      ));
+    }
 
     // --mermaid short-circuits before the dispatch analysis: visualizing the
     // plan's DAG doesn't need a sequential-vs-parallel decision.

package/src/core/paths/output-schema.js

@@ -49,6 +49,11 @@ export const OUTPUT_SCHEMA = {
 
   // 4-review/
   reviewReport:   { filename: 'review-report.md',      phaseDir: '4-review',    phase: 'review',    protected: false },
+  // Durable report the dispatched morph-evaluator sub-agent writes itself
+  // (MORPH.md §6) — the orchestrator reads it and synthesizes reviewReport
+  // from it; the two never collide because one is raw sub-agent output and
+  // the other is the orchestrator's curated Gate 3 presentation.
+  evaluatorReport:{ filename: 'evaluator-report.md',   phaseDir: '4-review',    phase: 'review',    protected: false },
 };
 
 // ============================================================================
@@ -89,6 +94,29 @@ export function getFeatureDir(featureName) {
   return join('.morph', 'features', featureName).replace(/\\/g, '/');
 }
 
+/**
+ * Per-task sub-agent report — the durable "return value" channel for a
+ * dispatched implementation task (MORPH.md §6). A sub-agent's final text
+ * message may never reach the orchestrator (idle_notification with no text
+ * is an observed failure mode); the file it writes here always does. Doesn't
+ * fit OUTPUT_SCHEMA's one-fixed-filename-per-type model since the filename
+ * is parameterized by taskId, so it's a sibling helper instead of a schema
+ * entry.
+ *
+ * @param {string} featureName
+ * @param {string} taskId - e.g. "T7"
+ * @returns {string} morph-relative, forward-slash path
+ */
+export function getTaskReportPath(featureName, taskId) {
+  return join('.morph', 'features', featureName, '3-implement', 'reports', `${taskId}.md`)
+    .replace(/\\/g, '/');
+}
+
+/** Absolute filesystem variant of {@link getTaskReportPath}. */
+export function getAbsoluteTaskReportPath(projectRoot, featureName, taskId) {
+  return join(projectRoot, '.morph', 'features', featureName, '3-implement', 'reports', `${taskId}.md`);
+}
+
 /**
  * Get all output paths for a feature, ready for state.json `outputs` block.
  */

package/src/core/state/state-manager.js

@@ -472,7 +472,6 @@ async function ensureFeature(featureName) {
       status: "draft",
       createdAt: new Date().toISOString(),
       updatedAt: new Date().toISOString(),
-      activeAgents: [],
       approvalGates: {
         proposal: { approved: false, timestamp: null, approvedBy: null },
         uiux: { approved: false, timestamp: null, approvedBy: null },
@@ -486,7 +485,6 @@ async function ensureFeature(featureName) {
         pending: 0
       },
       checkpoints: [],
-      dispatchLog: [],
       trustConfig: {},
       contextBundles: [],
       fileChanges: []
@@ -533,7 +531,6 @@ export async function createFeature(featureName, options = {}) {
     workType: workType || 'feature',
     createdAt: now,
     updatedAt: now,
-    activeAgents: [],
     approvalGates: {
       proposal: { approved: false, timestamp: null, approvedBy: null },
       uiux: { approved: false, timestamp: null, approvedBy: null },
@@ -549,7 +546,6 @@ export async function createFeature(featureName, options = {}) {
       pending: 0
     },
     checkpoints: [],
-    dispatchLog: [],
     trustConfig: {},
     contextBundles: [],
     fileChanges: []
@@ -649,73 +645,6 @@ export async function addCheckpoint(featureName, note) {
   return checkpoint;
 }
 
-/**
- * Add agent to feature
- * @param {string} featureName - Feature name
- * @param {string} agentId - Agent ID
- * @returns {boolean} True if added, false if already exists
- */
-export async function addAgent(featureName, agentId) {
-  await ensureFeature(featureName);
-  const state = loadState(); // Load AFTER ensuring feature exists
-
-  if (!state.features[featureName].activeAgents.includes(agentId)) {
-    state.features[featureName].activeAgents.push(agentId);
-    state.features[featureName].updatedAt = new Date().toISOString();
-    saveState(state);
-    return true;
-  }
-
-  return false;
-}
-
-/**
- * Remove agent from feature
- * @param {string} featureName - Feature name
- * @param {string} agentId - Agent ID
- * @returns {boolean} True if removed, false if not found
- */
-export function removeAgent(featureName, agentId) {
-  const state = loadState();
-
-  if (!state.features[featureName]) {
-    throw new Error(`Feature '${featureName}' not found.`);
-  }
-
-  const index = state.features[featureName].activeAgents.indexOf(agentId);
-  if (index > -1) {
-    state.features[featureName].activeAgents.splice(index, 1);
-    state.features[featureName].updatedAt = new Date().toISOString();
-    saveState(state);
-    return true;
-  }
-
-  return false;
-}
-
-/**
- * Log a dispatch event to state.json.
- * Appends entry to feature.dispatchLog, capped at 50 entries (oldest trimmed).
- *
- * @param {string} featureName - Feature name
- * @param {{ timestamp: string, phase: string, mode: string, agents: Array<{ id: string, subagentType: string, group: string, tasks: string[] }> }} entry - Dispatch event to log
- */
-export function logDispatch(featureName, entry) {
-  const state = loadState();
-  const feature = state.features?.[featureName];
-  if (!feature) return;
-
-  if (!Array.isArray(feature.dispatchLog)) feature.dispatchLog = [];
-  feature.dispatchLog.push(entry);
-
-  // Cap at 50 entries
-  if (feature.dispatchLog.length > 50) {
-    feature.dispatchLog = feature.dispatchLog.slice(-50);
-  }
-
-  saveState(state);
-}
-
 /**
  * Normalize output type from kebab-case to camelCase (BUG-002 fix - Enhanced)
  * Supports both kebab-case and camelCase input formats for all output types
@@ -1103,60 +1032,3 @@ export function getApprovalHistory(featureName) {
   // Sort by timestamp
   return history.sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp));
 }
-
-/**
- * Find which agent was assigned a specific task in the latest dispatch.
- * Searches only the last dispatchLog entry.
- *
- * @param {string} featureName
- * @param {string} taskId
- * @returns {string|null} Agent ID or null if not found
- */
-export function resolveAgentForTask(featureName, taskId) {
-  const state = loadState();
-  const feature = state.features?.[featureName];
-  if (!feature) return null;
-
-  const log = feature.dispatchLog;
-  if (!Array.isArray(log) || log.length === 0) return null;
-
-  const latest = log[log.length - 1];
-  for (const agent of latest.agents || []) {
-    if (Array.isArray(agent.tasks) && agent.tasks.includes(taskId)) {
-      return agent.id;
-    }
-  }
-  return null;
-}
-
-/**
- * Update timing fields on a specific agent in the latest dispatch entry.
- * Fail-open: returns silently if feature/dispatch/agent not found.
- *
- * @param {string} featureName
- * @param {string} agentId - Agent ID to update
- * @param {Object} updates - Fields to merge (startedAt, completedAt, tasksCompleted)
- */
-export function updateDispatchAgentTiming(featureName, agentId, updates) {
-  const state = loadState();
-  const feature = state.features?.[featureName];
-  if (!feature) return;
-
-  const log = feature.dispatchLog;
-  if (!Array.isArray(log) || log.length === 0) return;
-
-  const latest = log[log.length - 1];
-  const agent = (latest.agents || []).find(a => a.id === agentId);
-  if (!agent) return;
-
-  Object.assign(agent, updates);
-
-  // If all agents now have completedAt, set entry.completedAt to the latest
-  const allComplete = (latest.agents || []).every(a => a.completedAt);
-  if (allComplete && latest.agents.length > 0) {
-    const timestamps = latest.agents.map(a => new Date(a.completedAt).getTime());
-    latest.completedAt = new Date(Math.max(...timestamps)).toISOString();
-  }
-
-  saveState(state);
-}

package/src/dashboard/app/pages/LiveState.jsx

@@ -98,33 +98,6 @@ function TaskList({ taskList }) {
   );
 }
 
-function DispatchLog({ dispatchLog }) {
-  if (!dispatchLog?.length) return null;
-
-  return (
-    <div className="mt-3">
-      <p className="text-gray-500 text-[10px] uppercase tracking-wide mb-1.5">Dispatch Log</p>
-      <div className="space-y-1 border-l-2 border-gray-700 pl-3">
-        {dispatchLog.map((entry, i) => (
-          <div key={i} className="relative">
-            <span className="absolute -left-4 top-1 w-2 h-2 rounded-full bg-gray-600 border border-gray-500" />
-            <div className="text-[10px] text-gray-500">
-              {entry.timestamp && (
-                <span className="font-mono mr-2">
-                  {new Date(entry.timestamp).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })}
-                </span>
-              )}
-              <span className="text-blue-400 font-mono">{entry.agent || entry.agentId}</span>
-              {entry.task && <span className="text-gray-400 ml-1">→ {entry.task}</span>}
-              {entry.action && <span className="text-gray-400 ml-1">{entry.action}</span>}
-            </div>
-          </div>
-        ))}
-      </div>
-    </div>
-  );
-}
-
 function FeatureCard({ featureId, feature }) {
   const status = feature.status || 'draft';
   const phase = feature.phase || feature.currentPhase || PHASE_ORDER[0];
@@ -134,7 +107,6 @@ function FeatureCard({ featureId, feature }) {
     : typeof feature.taskList === 'object' && feature.taskList !== null
       ? Object.values(feature.taskList)
       : [];
-  const dispatchLog = feature.dispatchLog || [];
 
   return (
     <div className="bg-gray-900 border border-gray-700 rounded-xl p-4 space-y-3">
@@ -169,21 +141,6 @@ function FeatureCard({ featureId, feature }) {
           <TaskList taskList={taskList} />
         </div>
       )}
-
-      {/* Dispatch log */}
-      <DispatchLog dispatchLog={dispatchLog} />
-
-      {/* Active agents */}
-      {feature.activeAgents?.length > 0 && (
-        <div>
-          <p className="text-gray-500 text-[10px] uppercase tracking-wide mb-1.5">Active Agents</p>
-          <div className="flex flex-wrap gap-1">
-            {feature.activeAgents.map((a) => (
-              <span key={a} className="px-2 py-0.5 bg-gray-800 border border-gray-700 rounded text-[10px] font-mono text-gray-300">{a}</span>
-            ))}
-          </div>
-        </div>
-      )}
     </div>
   );
 }

package/src/lib/detectors/design-system-detector.js

@@ -150,49 +150,6 @@ export function detectDesignSystem(projectPath, featureName = null) {
   return result;
 }
 
-/**
- * Check if UI agents are active for a feature
- * @param {string} projectPath - Root path of the project
- * @param {string} featureName - Feature name
- * @returns {boolean} True if UI agents are active
- */
-export function hasUIAgentsActive(projectPath, featureName) {
-  try {
-    const statePath = join(projectPath, '.morph/state.json');
-
-    if (!existsSync(statePath)) {
-      return false;
-    }
-
-    const state = JSON.parse(readFileSync(statePath, 'utf8'));
-
-    // Handle both array and object format
-    let feature;
-    if (Array.isArray(state.features)) {
-      feature = state.features.find(f => f.name === featureName);
-    } else if (state.features && typeof state.features === 'object') {
-      feature = state.features[featureName];
-    }
-
-    if (!feature || !feature.activeAgents) {
-      return false;
-    }
-
-    // UI design agents that require a design system before implement phase.
-    // Implementation-only agents (nextjs-expert, css-specialist)
-    // build from existing designs and do NOT trigger this gate.
-    const uiAgents = [
-      'ui-designer',
-      'uiux-designer',
-      'ui-ux-designer',
-    ];
-
-    return feature.activeAgents.some(agentId => uiAgents.includes(agentId));
-  } catch {
-    return false;
-  }
-}
-
 /**
  * Get recommended design system locations based on project type
  * @param {string} projectPath - Root path of the project

package/src/lib/generators/index.js

@@ -6,6 +6,5 @@
 
 export * from './design-system-generator.js';
 export * from './handoff-generator.js';
-export * from './metadata-extractor.js';
 export * from './architecture-scanner.js';
 export * from './scaffold-generator.js';