@polymorphism-tech/morph-spec 8.38.0 → 8.41.0

package/src/commands/mcp/mcp-setup.js

@@ -64,21 +64,49 @@ export async function detectStack(targetPath) {
   }
 }
 
+/**
+ * Detect the project's integrations (`neon`, `stripe`...), same sources and
+ * order as detectStack. The detectors never fold them into the stack string, so
+ * without this an MCP scoped to an integration (neon, asaas) is never offered.
+ *
+ * @param {string} targetPath
+ * @returns {Promise<string[]>}
+ */
+export async function detectIntegrations(targetPath) {
+  try {
+    const configPath = join(targetPath, '.morph', 'config', 'config.json');
+    if (existsSync(configPath)) {
+      const integrations = JSON.parse(readFileSync(configPath, 'utf-8')).project?.integrations;
+      if (Array.isArray(integrations)) return integrations;
+    }
+  } catch {
+    // Fall through to filesystem detection
+  }
+
+  try {
+    const results = await detectProject(targetPath, { conversation: false, generateStandards: false });
+    return results.structure?.integrations ?? [];
+  } catch {
+    return [];
+  }
+}
+
 export async function mcpSetupCommand(name, options) {
   const targetPath = process.cwd();
 
   try {
     // Detect current environment
     const stack = await detectStack(targetPath);
+    const integrations = await detectIntegrations(targetPath);
     const claudeConfig = await detectClaudeConfig(targetPath);
     const existingMcps = claudeConfig.mcpServers || [];
 
     if (options.list) {
-      return showStatusList(targetPath, stack, existingMcps);
+      return showStatusList(targetPath, stack, existingMcps, integrations);
     }
 
     if (options.auto) {
-      return autoInstall(targetPath, stack, existingMcps);
+      return autoInstall(targetPath, stack, existingMcps, integrations);
     }
 
     if (name) {
@@ -86,7 +114,7 @@ export async function mcpSetupCommand(name, options) {
     }
 
     // Interactive wizard
-    return interactiveWizard(targetPath, stack, existingMcps);
+    return interactiveWizard(targetPath, stack, existingMcps, integrations);
   } catch (err) {
     console.error(chalk.red(`Error: ${err.message}`));
     process.exit(1);
@@ -96,8 +124,8 @@ export async function mcpSetupCommand(name, options) {
 /**
  * Show MCP status list (--list)
  */
-async function showStatusList(targetPath, stack, existingMcps) {
-  const orchestration = orchestrateMcpSetup(targetPath, stack, existingMcps);
+async function showStatusList(targetPath, stack, existingMcps, integrations) {
+  const orchestration = orchestrateMcpSetup(targetPath, stack, existingMcps, { integrations });
   const statusRows = formatMcpStatusTable(orchestration, {});
 
   console.log(chalk.cyan('\n  MCP Server Status\n'));
@@ -130,8 +158,8 @@ async function showStatusList(targetPath, stack, existingMcps) {
 /**
  * Auto-install credential-free MCPs (--auto)
  */
-async function autoInstall(targetPath, stack, existingMcps) {
-  const orchestration = orchestrateMcpSetup(targetPath, stack, existingMcps, { autoOnly: true });
+async function autoInstall(targetPath, stack, existingMcps, integrations) {
+  const orchestration = orchestrateMcpSetup(targetPath, stack, existingMcps, { autoOnly: true, integrations });
   const autoNames = Object.keys(orchestration.autoInstallable);
 
   if (autoNames.length === 0) {
@@ -391,8 +419,8 @@ async function setupSpecificMcp(targetPath, name, stack, existingMcps) {
 /**
  * Interactive wizard showing all MCPs
  */
-async function interactiveWizard(targetPath, stack, existingMcps) {
-  const orchestration = orchestrateMcpSetup(targetPath, stack, existingMcps);
+async function interactiveWizard(targetPath, stack, existingMcps, integrations) {
+  const orchestration = orchestrateMcpSetup(targetPath, stack, existingMcps, { integrations });
 
   console.log(chalk.cyan('\n  MCP Setup Wizard'));
   console.log(chalk.gray(`  Stack: ${stack}`));

package/src/commands/project/doctor.js

@@ -16,7 +16,7 @@ import {
   getInstalledCLIVersion
 } from '../../utils/version-checker.js';
 import { resetMorphSettings } from '../../utils/claude-settings-manager.js';
-import { checkMissingAgents, checkAgentsDrift, maxTurnsError, surfacesError } from '../../utils/agents-installer.js';
+import { checkMissingAgents, checkAgentsDrift, maxTurnsError, surfacesError, effortError } from '../../utils/agents-installer.js';
 import { getProjectTags } from '../../lib/stack-filter.js';
 import { auditGraph } from '../../lib/graph/graph-health.js';
 import { auditFeatureLifecycle } from '../../core/state/lifecycle-audit.js';
@@ -44,10 +44,10 @@ function normCwd(root, cwd) {
 /**
  * Check which required Claude Code plugins are installed.
  * @param {Object} pluginsData - The `plugins` object from installed_plugins.json
- * @returns {{ superpowers: boolean, context7: boolean }}
+ * @returns {{ context7: boolean }}
  */
 export function checkInstalledPlugins(pluginsData) {
-  const REQUIRED = ['superpowers', 'context7'];
+  const REQUIRED = ['context7'];
   return Object.fromEntries(
     REQUIRED.map(name => [name, `${name}@claude-plugins-official` in (pluginsData || {})])
   );
@@ -208,6 +208,14 @@ export function validateAgentsJson(agentsData) {
     ? { name: 'agents.json surfaces', status: 'error', msg: surfacesErrors.join(' | ') }
     : { name: 'agents.json surfaces', status: 'ok' });
 
+  // 6: effort — same installer rule, same severity.
+  const effortErrors = agentEntries
+    .map(([id, data]) => effortError(id, data?.effort))
+    .filter(Boolean);
+  checks.push(effortErrors.length > 0
+    ? { name: 'agents.json effort', status: 'error', msg: effortErrors.join(' | ') }
+    : { name: 'agents.json effort', status: 'ok' });
+
   if (missingV5Fields.length > 0 && isV5) {
     const sample = missingV5Fields.slice(0, 3).join(', ');
     checks.push({
@@ -1330,15 +1338,13 @@ export async function doctorCommand(options = {}) {
       } catch { /* non-fatal */ }
 
       // ── Claude Code Plugins ──────────────────────────────────────────────────
-      console.log(chalk.cyan('\n  Claude Code Plugins (required for /morph-init)'));
+      console.log(chalk.cyan('\n  Claude Code Plugins (required by morph-spec init)'));
       const pluginsFile = join(homedir(), '.claude', 'plugins', 'installed_plugins.json');
       let pluginData = { plugins: {} };
       try {
         pluginData = JSON.parse(await fs.readFile(pluginsFile, 'utf8'));
       } catch { /* file may not exist */ }
       const pluginStatus = checkInstalledPlugins(pluginData.plugins || {});
-      check('superpowers plugin', pluginStatus.superpowers, false,
-        'Run: morph-spec install-plugin superpowers');
       check('context7 plugin', pluginStatus.context7, false,
         'Run: morph-spec install-plugin context7');
     } else {

package/src/commands/project/init.js

@@ -34,6 +34,7 @@ import { installAgents, installDomainAgents } from '../../utils/agents-installer
 import { getProjectTags } from '../../lib/stack-filter.js';
 import { updateCommand } from './update.js';
 import { resolvePrimaryRoot } from './worktree.js';
+import { registerProject } from '../../lib/projects/registry.js';
 
 /**
  * Guard against running a full `init` install from inside a secondary
@@ -135,8 +136,7 @@ export async function initCommand(options) {
     try {
       claudeConfigDetected = await detectClaudeConfig(targetPath);
       const hasIntegrations = claudeConfigDetected.plugins.length > 0
-        || claudeConfigDetected.mcpServers.length > 0
-        || claudeConfigDetected.superpowers.installed;
+        || claudeConfigDetected.mcpServers.length > 0;
 
       if (hasIntegrations) {
         spinner.stop();
@@ -287,7 +287,8 @@ export async function initCommand(options) {
       try {
         spinner.stop();
         const existingMcps = claudeConfigDetected?.mcpServers || [];
-        const orchestration = orchestrateMcpSetup(targetPath, detectedStack, existingMcps);
+        const orchestration = orchestrateMcpSetup(targetPath, detectedStack, existingMcps,
+          { integrations: config.project?.integrations ?? [] });
 
         const autoNames = Object.keys(orchestration.autoInstallable);
         const manualNames = Object.keys(orchestration.needsManualSetup);
@@ -467,6 +468,8 @@ export async function initCommand(options) {
     }
 
     spinner.succeed('MORPH-SPEC installed successfully!');
+    // The dashboard's portfolio learns about the project here (fail-open).
+    registerProject(targetPath, 'init');
 
     // Show next steps
     logger.blank();

package/src/commands/project/install-plugin-cmd.js

@@ -5,7 +5,7 @@ import { logger } from '../../utils/logger.js';
 export async function installPluginCommand(pluginName, _options) {
   if (!pluginName) {
     logger.error('Plugin name required. Usage: morph-spec install-plugin <name>');
-    logger.dim('  Available: superpowers, context7');
+    logger.dim('  Available: context7');
     process.exit(1);
   }
   try {

package/src/commands/project/update.js

@@ -33,6 +33,7 @@ import { getProjectTags } from '../../lib/stack-filter.js';
 import { updateClaudeMdAgentsBlock, installRulesForStack } from '../../scripts/setup-infra.js';
 import { reconcileLegacyTemplatesCopy } from '../../lib/installers/templates-reconcile.js';
 import { createEffects } from '../../lib/installers/effects.js';
+import { registerProject } from '../../lib/projects/registry.js';
 import {
   writeGraphifyignore, describeOutdatedIgnore, graphifyignoreTracked,
 } from '../../lib/graph/graphifyignore.js';
@@ -758,6 +759,10 @@ export async function updateCommand(options = {}) {
     logger.blank();
 
     if (!dryRun) {
+      // The dashboard's portfolio learns about the project here (fail-open;
+      // outside the project, so not an effect of the update itself).
+      registerProject(targetPath, 'update');
+
       // Show version change
       if (projectCheck.current && projectCheck.current !== cliCheck.current) {
         logger.success(`Updated: ${projectCheck.current} → ${cliCheck.current}`);

package/src/commands/project/worktree.js

@@ -35,7 +35,7 @@
  */
 
 import { execSync, execFileSync } from 'child_process';
-import { existsSync, mkdirSync, symlinkSync, readFileSync, writeFileSync, lstatSync, unlinkSync, rmdirSync, cpSync } from 'fs';
+import { existsSync, mkdirSync, symlinkSync, readFileSync, writeFileSync, lstatSync, unlinkSync, rmdirSync, cpSync, copyFileSync, readdirSync } from 'fs';
 import { join, resolve, dirname, basename } from 'path';
 import chalk from 'chalk';
 import { detectDefaultBranch } from '../../lib/git/default-branch.js';
@@ -612,6 +612,43 @@ export function buildTaskBranchName(name) {
   return `morph-task/${name}`;
 }
 
+const ROOT_ENV_FILE_RE = /^\.env(\..+)?$/;
+
+/**
+ * Copy the root's `.env` / `.env.*` into a new tree: a sub-agent that builds
+ * or runs the app needs the same secrets, and they are never committed. Only
+ * a REAL file (never a link — nothing in the tree may reach the root through
+ * one), only when the tree lacks it (never overwrite), and only when git
+ * IGNORES it there: an untracked-but-visible copy would dirty the tree, and
+ * `finish`/`worktree remove --if-clean` refuse a dirty tree. At teardown the
+ * copy is byte-identical to the root's, which `triageIgnoredPaths` classifies
+ * as REPLICABLE — deleted with nothing lost.
+ *
+ * @param {string} worktreePath
+ * @param {string} root
+ * @returns {string[]} names copied
+ */
+export function copyRootEnvFiles(worktreePath, root) {
+  let names;
+  try {
+    names = readdirSync(root).filter((n) => ROOT_ENV_FILE_RE.test(n));
+  } catch {
+    return [];
+  }
+  const copied = [];
+  for (const name of names) {
+    const dst = join(worktreePath, name);
+    try {
+      if (!lstatSync(join(root, name)).isFile()) continue;
+      try { lstatSync(dst); continue; } catch { /* absent — not even a dangling link */ }
+      execFileSync('git', ['check-ignore', '-q', '--', name], { cwd: worktreePath, stdio: 'pipe' });
+      copyFileSync(join(root, name), dst);
+      copied.push(name);
+    } catch { /* not ignored, unreadable or unwritable — leave it out */ }
+  }
+  return copied;
+}
+
 /**
  * Non-exiting core of `worktree provision` — the tree `claude -w`,
  * `EnterWorktree` and `Agent isolation:"worktree"` ask for when the name is
@@ -668,7 +705,11 @@ export async function runWorktreeProvision(name, options = {}) {
     execFileSync('git', ['worktree', 'add', worktreePath, branch], { cwd: root, stdio: 'pipe' });
 
     setupInfraLinks(worktreePath, root);
-    const envBlock = await allocateWorktreeEnv(worktreePath, root, `task/${name}`);
+    const envFiles = copyRootEnvFiles(worktreePath, root);
+    // A tree born from `morph/<f>` works FOR that feature: MORPH_FEATURE says
+    // so, while the port block stays the task's own (`task/<name>`).
+    const forFeature = String(options.base || '').match(/^morph\/(.+)$/)?.[1] ?? null;
+    const envBlock = await allocateWorktreeEnv(worktreePath, root, `task/${name}`, { morphFeature: forFeature });
     const materialized = await ensureLocalState(worktreePath);
     const graph = seedWorktreeGraph(worktreePath, root);
 
@@ -681,6 +722,8 @@ export async function runWorktreeProvision(name, options = {}) {
       branchedFrom,
       kind: 'task-isolation',
       name,
+      ...(forFeature ? { feature: forFeature } : {}),
+      ...(envFiles.length ? { envFiles } : {}),
       materialized: materialized.materialized,
       ...(envBlock ? { env: { base: envBlock.base, range: envBlock.range } } : {}),
       ...(graph.seeded ? { graph: 'seeded' } : {}),
@@ -797,12 +840,25 @@ export function envKeyForWorktree(worktreePath, root) {
  * Shared by `setup` (feature key), `provision` (task key) and `link --all`
  * (regeneration), so the manifest has exactly one writer.
  *
+ * `morphFeature` (task trees born from `morph/<f>`) only renames the
+ * `MORPH_FEATURE` line. Left undefined — the `link --all` regeneration, which
+ * derives the key from the branch and cannot see the base — the value the
+ * file already carries is kept, so a repair never forgets the feature.
+ *
  * @param {string} worktreePath
  * @param {string} root - primary root
  * @param {string} envKey - `<feature>` or `task/<name>`
+ * @param {{ morphFeature?: string|null }} [opts]
  * @returns {Promise<{ index: number, base: number, range: [number, number] }|null>}
  */
-export async function allocateWorktreeEnv(worktreePath, root, envKey) {
+export async function allocateWorktreeEnv(worktreePath, root, envKey, { morphFeature } = {}) {
+  const envPath = join(worktreePath, '.morph', 'worktree.env');
+  if (morphFeature === undefined && envKey.startsWith('task/')) {
+    try {
+      const kept = readFileSync(envPath, 'utf8').match(/^MORPH_FEATURE=(.+)$/m)?.[1]?.trim();
+      morphFeature = kept && kept !== envKey ? kept : null;
+    } catch { morphFeature = null; }
+  }
   try {
     const { allocateEnvBlock, resolveFleetConfig, buildEnvFileContent } =
       await import('../../lib/worktree/env-allocator.js');
@@ -816,7 +872,7 @@ export async function allocateWorktreeEnv(worktreePath, root, envKey) {
       stack = cfg?.project?.stack || '';
     } catch { /* fail-open — stackless env still carries PORT */ }
     mkdirSync(join(worktreePath, '.morph'), { recursive: true });
-    writeFileSync(join(worktreePath, '.morph', 'worktree.env'), buildEnvFileContent(envKey, block, stack), 'utf8');
+    writeFileSync(envPath, buildEnvFileContent(envKey, block, stack, { morphFeature }), 'utf8');
     excludeWorktreePaths(root, [join('.morph', 'worktree.env')]);
     return block;
   } catch {

package/src/commands/state/gate-check.js

@@ -9,6 +9,7 @@ import { persistGateDecision, VALID_GATES, readTrustFromConfig } from './gate-de
 import { minimatch } from 'minimatch';
 import { detectDefaultBranch, getHeadSha, getDiffStat, changedPathsAgainst } from '../../lib/git/default-branch.js';
 import { readMorphConfig } from '../../lib/tasks/test-runner.js';
+import { oversizedTasks } from '../../lib/tasks/tasks-json-parser.js';
 import { assertOwnerTree, ownerTreeRefusalLines } from '../../lib/worktree/feature-truth.js';
 
 /**
@@ -196,6 +197,10 @@ function collectSignals(featureName, feature, cwd, gateName) {
     designSystemDivergence: false,
   };
 
+  // Fato de disco, fora de OVERRIDABLE_SIGNAL_KEYS: task que não cabe num
+  // dispatch se fatia no plano, não depois de um sub-agent bater no teto.
+  if (gateName === 'plan') signals.oversizedTasks = oversizedTasks({ tasks });
+
   // Só onde o checklist decide algo: no fecho do design e no ship. Fato de
   // disco, fora de OVERRIDABLE_SIGNAL_KEYS como `mutationProof`.
   if (gateName === 'uiux' || gateName === 'review') {

package/src/commands/tasks/dag.js

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
-import { existsSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
-import { parseTasksJsonLenient } from '../../lib/tasks/tasks-json-parser.js';
+import { parseTasksJsonLenient, oversizedTasks, MAX_TASK_OUTPUTS } from '../../lib/tasks/tasks-json-parser.js';
 import { planDispatch } from '../../lib/tasks/dispatch-planner.js';
 import { renderMermaidFlowchart } from '../../lib/tasks/mermaid-renderer.js';
 import { checkUseCases } from '../../lib/specs/usecase-check.js';
@@ -16,6 +16,15 @@ export function printLifecycleWarnings(lifecycle) {
   for (const w of lifecycle.warnings) console.error(chalk.yellow(`  ${w}`));
 }
 
+function planGateApproved(featureDir) {
+  try {
+    const feature = JSON.parse(readFileSync(join(featureDir, 'feature.json'), 'utf8'));
+    return feature?.approvalGates?.plan?.approved === true;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * `morph-spec dag <feature>` — analyze the tasks.json DAG and print the
  * sequential vs parallel dispatch decision, weighted by effort.
@@ -72,11 +81,17 @@ export async function dagCommand(featureName, options = {}) {
     // revocation rows the finish would fail to apply. Warnings only.
     const lifecycle = checkLifecycle({ cwd: process.cwd(), featureDir, tasksData: data });
 
+    // Task acima do teto não cabe num dispatch. Antes do Gate 2 é erro (o plano
+    // ainda fatia); depois é aviso, para não travar feature em voo.
+    const oversized = oversizedTasks(data);
+    const sizeBlocks = oversized.length > 0 && !planGateApproved(featureDir);
+    const taskSize = { max: MAX_TASK_OUTPUTS, oversized, blocking: sizeBlocks };
+
     const plan = planDispatch(data);
 
     if (options.json) {
-      console.log(JSON.stringify({ ...plan, useCases: ucCheck, artifactCriteria, lifecycle }, null, 2));
-      if (ucCheck.errors.length) process.exit(1);
+      console.log(JSON.stringify({ ...plan, useCases: ucCheck, artifactCriteria, lifecycle, taskSize }, null, 2));
+      if (ucCheck.errors.length || sizeBlocks) process.exit(1);
       return;
     }
 
@@ -88,6 +103,14 @@ export async function dagCommand(featureName, options = {}) {
       console.error(chalk.gray('\n  Corrija a referência no tasks.json ou restaure o use case.\n'));
       process.exit(1);
     }
+    if (oversized.length) {
+      const tone = sizeBlocks ? chalk.red : chalk.yellow;
+      const head = sizeBlocks ? '❌' : '⚠';
+      console.error(tone(`\n${head} Tamanho de task — ${plural(oversized.length, 'task', 'tasks')} acima de ${MAX_TASK_OUTPUTS} outputs`));
+      for (const t of oversized) console.error(tone(`  ${t.id}: ${t.outputs} outputs`));
+      console.error(chalk.gray('  Fatie por pós-condição: uma task cabe num dispatch (morph-plan, "Tamanho da task").\n'));
+      if (sizeBlocks) process.exit(1);
+    }
     if (ucCheck.warnings.length) {
       console.error(chalk.yellow(`\n⚠ Use cases — ${plural(ucCheck.warnings.length, 'aviso', 'avisos')}`));
       for (const w of ucCheck.warnings) console.error(chalk.yellow(`  ${w}`));

package/src/commands/validation/verify.js

@@ -1,9 +1,10 @@
 import chalk from 'chalk';
-import { readFileSync } from 'fs';
-import { resolve, join } from 'path';
+import { resolve } from 'path';
 import { getFeature, updateFeature } from '../../core/state/state-manager.js';
 import { runVerify, readTask, VerifyUsageError } from '../../lib/validators/verify-runner.js';
 import { resolvePrimaryRoot } from '../project/worktree.js';
+import { resolveFeatureTree } from '../../lib/worktree/feature-truth.js';
+import { canonicalPath } from '../../lib/tasks/test-runner.js';
 import { getHeadSha } from '../../lib/git/default-branch.js';
 import { EVAL_RUNNER } from '../../lib/tasks/eval-node.js';
 import { buildVerifyEvent, recordVerifyEvent, findRepeatedVerify } from '../../lib/telemetry/verify-event.js';
@@ -93,25 +94,25 @@ function formatVerifyResult(result) {
   return lines.join('\n');
 }
 
+const samePath = (a, b) => canonicalPath(a).replace(/\\/g, '/') === canonicalPath(b).replace(/\\/g, '/');
+
 /**
- * Decide whether it's safe to persist a verify result to feature.json.
+ * Persist only in the tree that OWNS the feature — the same predicate
+ * `list`/`handoff`/the mutator guard read (`resolveFeatureTree`), asked from
+ * the PRIMARY ROOT so every tree gets the same answer. Any other tree (a
+ * sub-agent's `morph-task/*` tree branched from `morph/{f}`, a scratch
+ * checkout) must never write feature.json: its copy is not the one the gates
+ * read, and the write would merge-conflict with the owner's.
  *
- * Safe contexts: the primary git root, or the feature's own REGISTERED
- * worktree (`worktree.path` — where feature.json is authoritative and
- * travels with the branch). Any other worktree (e.g. a harness subagent's
- * temporary scratch worktree) must never write feature.json — that would
- * risk a merge conflict / violate the single-writer clause.
+ * The old rule read only the root's `worktree.path` pointer, which a feature
+ * created INSIDE its worktree never has: a `worktrees/homolog-v2` on
+ * `morph/chat-demo-simulacao` measured `unregistered-worktree` on 11/11 runs,
+ * and `repeatOf` (computed only when persisting) never fired. Git's worktree
+ * registry names that tree as the owner.
  *
- * Worktree registration is ROOT-OWNED data: `runWorktreeSetup` (see
- * src/commands/project/worktree.js) writes `.worktree` ONLY into the PRIMARY
- * ROOT's copy of feature.json (via saveState after chdir'ing back to root) —
- * it never touches the worktree's own branch-local copy. So this must read
- * the ROOT's feature.json to find the registration, never the cwd-local one
- * (`getFeature(featureName)` resolves relative to `process.cwd()`, which
- * inside a worktree is the branch-local copy and will never carry
- * `.worktree` — reading it here would make this branch permanently dead code
- * for the exact case it exists to handle: verify running from inside a
- * registered worktree).
+ * The root is not special: with a live worktree owning the feature, the
+ * root's copy is the birth-instant skeleton and a stamp there is drift —
+ * `owner-tree-elsewhere`, the verify side of `assertOwnerTree`.
  *
  * @param {{ cwd: string, featureName: string, noPersist: boolean }} params
  * @returns {{ persist: boolean, reason: string|null }}
@@ -120,26 +121,9 @@ function decidePersistence({ cwd, featureName, noPersist }) {
   if (noPersist) return { persist: false, reason: 'no-persist-flag' };
 
   const root = resolvePrimaryRoot(cwd);
-  const normalizedCwd = resolve(cwd).replace(/\\/g, '/');
-
-  if (normalizedCwd === root) return { persist: true, reason: null };
-
-  // cwd is (or looks like) a worktree — consult the ROOT's feature.json for
-  // the registration. Fail-open: an unreadable/missing root feature.json
-  // means we can't confirm registration, so treat as unregistered.
-  let registeredWt = null;
-  try {
-    const rootFeatureJsonPath = join(root, '.morph', 'features', featureName, 'feature.json');
-    const rootFeature = JSON.parse(readFileSync(rootFeatureJsonPath, 'utf8'));
-    registeredWt = rootFeature.worktree?.path
-      ? String(rootFeature.worktree.path).replace(/\\/g, '/')
-      : null;
-  } catch {
-    registeredWt = null;
-  }
-
-  if (registeredWt && normalizedCwd === registeredWt) return { persist: true, reason: null };
-  return { persist: false, reason: 'unregistered-worktree' };
+  const owner = resolveFeatureTree(featureName, root);
+  if (owner.tree && samePath(owner.tree, cwd)) return { persist: true, reason: null };
+  return { persist: false, reason: samePath(root, cwd) ? 'owner-tree-elsewhere' : 'unregistered-worktree' };
 }
 
 /**

package/src/dashboard/app/App.jsx

@@ -1,28 +1,92 @@
-import { Routes, Route, Navigate } from 'react-router-dom';
-import Sidebar from './components/Sidebar.jsx';
+import { useEffect, useState } from 'react';
+import { Routes, Route, Navigate, useLocation, useParams } from 'react-router-dom';
+import Sidebar, { MobileNav } from './components/Sidebar.jsx';
+import ErrorBoundary from './components/ErrorBoundary.jsx';
+import CommandPalette from './components/CommandPalette.jsx';
+import Portfolio from './pages/Portfolio.jsx';
+import Features, { isWorking } from './pages/Features.jsx';
+import FeatureDetail from './pages/FeatureDetail.jsx';
+import Activity from './pages/Activity.jsx';
 import AgentMap from './pages/AgentMap.jsx';
 import PhasePipeline from './pages/PhasePipeline.jsx';
 import HookInspector from './pages/HookInspector.jsx';
 import SkillsLibrary from './pages/SkillsLibrary.jsx';
 import RulesMap from './pages/RulesMap.jsx';
 import Standards from './pages/Standards.jsx';
-import LiveState from './pages/LiveState.jsx';
+import Guide from './pages/Guide.jsx';
+import Rubrics from './pages/Rubrics.jsx';
+import { useNow } from './hooks/usePref.js';
+import { useProjects, useCurrentProject, projectHref } from './lib/project.js';
+
+/**
+ * What the sidebar and the tab title say at a glance, from the portfolio:
+ * per project, how many features are active, waiting on you and being worked
+ * on right now.
+ */
+function usePulse(portfolio) {
+  const now = useNow();
+  const byProject = {};
+  for (const p of portfolio?.projects || []) {
+    const s = p.summary;
+    byProject[p.id] = s
+      ? { active: s.active, awaiting: s.awaiting, working: s.activeFeatures.filter((f) => isWorking(f, now)).length }
+      : null;
+  }
+  const awaiting = Object.values(byProject).reduce((n, x) => n + (x?.awaiting || 0), 0);
+  useEffect(() => {
+    document.title = awaiting ? `(${awaiting}) morph-spec` : 'morph-spec';
+  }, [awaiting]);
+  return { byProject, awaiting };
+}
+
+function ProjectIndex() {
+  const { project } = useParams();
+  return <Navigate to={projectHref(project)} replace />;
+}
 
 export default function App() {
+  const { pathname } = useLocation();
+  const { data: portfolio } = useProjects();
+  const current = useCurrentProject(portfolio);
+  const pulse = usePulse(portfolio);
+  const [palette, setPalette] = useState(false);
+  // Ctrl+K / Cmd+K opens the search from anywhere.
+  useEffect(() => {
+    const onKey = (e) => {
+      if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === 'k') { e.preventDefault(); setPalette((o) => !o); }
+    };
+    window.addEventListener('keydown', onKey);
+    return () => window.removeEventListener('keydown', onKey);
+  }, []);
+  const nav = { portfolio, current: current.id, pulse, onSearch: () => setPalette(true) };
   return (
-    <div className="flex h-screen bg-gray-950 text-gray-100 overflow-hidden">
-      <Sidebar />
-      <main className="flex-1 overflow-auto">
-        <Routes>
-          <Route path="/" element={<Navigate to="/agents" replace />} />
-          <Route path="/agents" element={<AgentMap />} />
-          <Route path="/phases" element={<PhasePipeline />} />
-          <Route path="/hooks" element={<HookInspector />} />
-          <Route path="/skills" element={<SkillsLibrary />} />
-          <Route path="/rules" element={<RulesMap />} />
-          <Route path="/standards" element={<Standards />} />
-          <Route path="/state" element={<LiveState />} />
-        </Routes>
+    <div className="flex h-full overflow-hidden">
+      <div className="ambient" aria-hidden="true" />
+      <Sidebar {...nav} />
+      <CommandPalette open={palette} onClose={() => setPalette(false)} portfolio={portfolio} project={current.id} />
+      <main className="relative z-10 flex-1 overflow-auto">
+        <MobileNav {...nav} />
+        {/* Inside <main>, keyed by route: a page that throws leaves the
+            sidebar alive, and navigating away remounts a clean boundary. */}
+        <ErrorBoundary key={pathname} page={pathname}>
+          <Routes>
+            <Route path="/" element={<Portfolio />} />
+            <Route path="/p/:project" element={<ProjectIndex />} />
+            <Route path="/p/:project/features" element={<Features />} />
+            <Route path="/p/:project/features/:name" element={<FeatureDetail />} />
+            <Route path="/p/:project/activity" element={<Activity />} />
+            <Route path="/guide" element={<Guide />} />
+            <Route path="/guide/:doc" element={<Guide />} />
+            <Route path="/rubrics" element={<Rubrics />} />
+            <Route path="/agents" element={<AgentMap />} />
+            <Route path="/phases" element={<PhasePipeline />} />
+            <Route path="/hooks" element={<HookInspector />} />
+            <Route path="/skills" element={<SkillsLibrary />} />
+            <Route path="/rules" element={<RulesMap />} />
+            <Route path="/standards" element={<Standards />} />
+            <Route path="*" element={<Navigate to="/" replace />} />
+          </Routes>
+        </ErrorBoundary>
       </main>
     </div>
   );