0xray 3.5.3 → 3.5.5

package/scripts/mjs/verify-pre-push-diff-core.mjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+/**
+ * Verify pre-push codex validation scopes to commit-range diff hunks.
+ */
+import { execSync } from 'node:child_process';
+import { mkdtempSync, mkdirSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageRoot = join(__dirname, '../..');
+
+const { getRangeAddedLinesByFile, scanAddedLinesForCodex } = await import(
+  join(packageRoot, 'scripts/hooks/run-hook.js')
+);
+
+let failed = 0;
+function pass(n) {
+  console.log(`✅ ${n}`);
+}
+function fail(n, d = '') {
+  failed++;
+  console.error(`❌ ${n}${d ? ` — ${d}` : ''}`);
+}
+
+function initGitRepo(dir) {
+  execSync('git init -q', { cwd: dir });
+  execSync('git config user.email "verify@0xray.test"', { cwd: dir });
+  execSync('git config user.name "verify"', { cwd: dir });
+}
+
+const tmp = mkdtempSync(join(tmpdir(), 'xray-prepush-diff-'));
+mkdirSync(join(tmp, 'src'), { recursive: true });
+initGitRepo(tmp);
+
+const file = 'src/push-flow.ts';
+const filePath = join(tmp, file);
+writeFileSync(
+  filePath,
+  `export function flow() {\n  console.log('legacy noise');\n  return 1;\n}\n`,
+);
+execSync('git add .', { cwd: tmp });
+execSync('git commit -q -m "baseline"', { cwd: tmp });
+const baseSha = execSync('git rev-parse HEAD', { cwd: tmp, encoding: 'utf8' }).trim();
+
+writeFileSync(
+  filePath,
+  `export function flow() {\n  console.log('legacy noise');\n  return 2;\n}\n`,
+);
+execSync('git add .', { cwd: tmp });
+execSync('git commit -q -m "return tweak"', { cwd: tmp });
+const headSha = execSync('git rev-parse HEAD', { cwd: tmp, encoding: 'utf8' }).trim();
+const range = `${baseSha}..${headSha}`;
+
+const added = getRangeAddedLinesByFile([file], range, tmp);
+const scanClean = scanAddedLinesForCodex(file, added.get(file) ?? []);
+if (scanClean.errors.length === 0) {
+  pass('ignores pre-existing console.log in commit-range diff');
+} else {
+  fail('pre-existing console.log leaked into range scan', scanClean.errors.join('; '));
+}
+
+writeFileSync(
+  filePath,
+  `export function flow() {\n  console.log('legacy noise');\n  console.log('push bad');\n  return 3;\n}\n`,
+);
+execSync('git add .', { cwd: tmp });
+execSync('git commit -q -m "bad push"', { cwd: tmp });
+const badHead = execSync('git rev-parse HEAD', { cwd: tmp, encoding: 'utf8' }).trim();
+const badRange = `${headSha}..${badHead}`;
+
+const addedBad = getRangeAddedLinesByFile([file], badRange, tmp);
+const scanBad = scanAddedLinesForCodex(file, addedBad.get(file) ?? []);
+if (scanBad.errors.length > 0) {
+  pass('flags console.log introduced in commit-range diff');
+} else {
+  fail('new console.log in push range was not flagged');
+}
+
+console.log(
+  '\n' +
+    (failed === 0
+      ? '🎉 Pre-push diff-scope verify passed (2/2).'
+      : `⚠️  ${failed} pre-push diff check(s) failed.`),
+);
+process.exit(failed === 0 ? 0 : 1);

package/scripts/mjs/verify-user-aside-core.mjs

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+/**
+ * verify-user-aside-core — user aside SSOT + spawn routing.
+ */
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getActiveUserAsideBoot } from '../../dist/integrations/hooks/user-aside-hook-runtime.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageRoot = join(__dirname, '../..');
+
+function dist(rel) {
+  return join(packageRoot, 'dist', rel);
+}
+
+const {
+  buildUserAsidePlan,
+  saveUserAside,
+  setActiveAsideId,
+  clearActiveAside,
+  getActiveAsideId,
+  isUserAsideTodoId,
+  assertSafeAsideId,
+  UserAsideValidationError,
+  getUserAsideBootHints,
+} = await import(dist('nucleus/user-aside.js'));
+const { resolveSpawnPlan } = await import(dist('nucleus/spawn-plan-resolution.js'));
+const { validateSpawnMatchesTodo } = await import(dist('nucleus/lead-dev-plan-persistence.js'));
+const { evaluatePreToolGate } = await import(dist('nucleus/delegation-gate.js'));
+
+let passed = 0;
+let failed = 0;
+const pass = (label) => {
+  passed += 1;
+  process.stdout.write(`✅ ${label}\n`);
+};
+const fail = (label, detail) => {
+  failed += 1;
+  process.stderr.write(`❌ ${label}${detail ? ` — ${detail}` : ''}\n`);
+};
+
+const tmp = mkdtempSync(join(tmpdir(), 'xray-user-aside-verify-'));
+mkdirSync(join(tmp, '.xray'), { recursive: true });
+writeFileSync(
+  join(tmp, '.xray/features.json'),
+  JSON.stringify({
+    multi_agent_orchestration: {
+      enabled: true,
+      lead_dev_mode: true,
+      user_asides: { enabled: true },
+    },
+  }),
+);
+
+try {
+  const namespaced = 'suit-nft.a.1.1';
+  if (!isUserAsideTodoId(namespaced)) fail('step 1: namespaced todo pattern');
+  else pass('step 1: namespaced todo pattern');
+
+  try {
+    assertSafeAsideId('../bad');
+    fail('step 2: path rejection');
+  } catch (err) {
+    if (err instanceof UserAsideValidationError) pass('step 2: rejects unsafe aside id');
+    else fail('step 2: path rejection', String(err));
+  }
+
+  const aside = buildUserAsidePlan(
+    'suit-nft',
+    'Suit NFT',
+    'Mint on Base',
+    [{ description: 'Groover proof', type: 'research' }],
+    35,
+    tmp,
+  );
+  if (aside?.plan.phases[0]?.todos[0]?.id !== 'suit-nft.a.1.1') {
+    fail('step 3: build aside plan', aside?.plan.phases[0]?.todos[0]?.id);
+  } else pass('step 3: namespaced aside todos');
+
+  saveUserAside(aside, tmp);
+  setActiveAsideId('suit-nft', tmp, 'verify-session');
+  if (getActiveAsideId(tmp, 'verify-session') !== 'suit-nft') fail('step 4: active pointer');
+  else pass('step 4: active aside pointer with session');
+
+  const todo = aside.plan.phases[0].todos[0];
+  const resolved = resolveSpawnPlan({ planTodoId: todo.id }, tmp, 'verify-session');
+  if (resolved.source !== 'aside') fail('step 5: resolve spawn plan', JSON.stringify(resolved));
+  else pass('step 5: spawn plan resolves to aside');
+
+  const validation = validateSpawnMatchesTodo(
+    { planTodoId: todo.id, subagent_type: todo.subagent, prompt: todo.id },
+    tmp,
+    undefined,
+    'verify-session',
+  );
+  if (!validation.valid) fail('step 6: spawn gate', validation.reason);
+  else pass('step 6: spawn gate accepts aside todo');
+
+  const boot = getUserAsideBootHints(tmp, 'verify-session');
+  if (!boot?.activeAside) fail('step 7: boot hints', JSON.stringify(boot));
+  else pass('step 7: session-boot hints from getUserAsideBootHints');
+
+  const hookBoot = getActiveUserAsideBoot(tmp, 'verify-session');
+  if (!hookBoot?.activeAside) fail('step 8: hook runtime', JSON.stringify(hookBoot));
+  else pass('step 8: user-aside-hook-runtime import');
+
+  clearActiveAside(tmp);
+  if (getActiveAsideId(tmp) !== null) fail('step 9: clear active');
+  else pass('step 9: clear active aside');
+
+  setActiveAsideId('suit-nft', tmp, 'verify-session');
+  const wtPath = join(tmp, 'aside-worktree');
+  aside.worktree = wtPath;
+  saveUserAside(aside, tmp);
+  const denySpawn = evaluatePreToolGate(
+    'Task',
+    { planTodoId: todo.id, subagent_type: todo.subagent, prompt: todo.id },
+    {
+      projectRoot: tmp,
+      sessionId: 'verify-session',
+      features: { lead_dev_mode: true, auto_chain_delegations: true },
+    },
+  );
+  if (denySpawn.allow) fail('step 10: worktree cwd deny', JSON.stringify(denySpawn));
+  else if (denySpawn.gate !== 'aside-worktree-cwd-missing') {
+    fail('step 10: worktree cwd gate', denySpawn.gate);
+  } else pass('step 10: denies aside spawn without worktree cwd');
+} finally {
+  rmSync(tmp, { recursive: true, force: true });
+}
+
+process.stdout.write(
+  `\n${failed === 0 ? `✅ verify-user-aside-core ${passed}/${passed}` : `⚠️  ${failed} user-aside check(s) failed`}\n`,
+);
+process.exit(failed > 0 ? 1 : 0);

package/scripts/node/bridge-mcp-wiring.cjs

@@ -121,6 +121,15 @@ function buildPortableProjectMcpJson() {
   return { mcpServers };
 }
 
+function copyHermesFindProjectRootHelper(packageRoot, targetPluginDir) {
+  const helperSrc = path.join(packageRoot, "scripts", "helpers", "find-project-root.mjs");
+  if (!fs.existsSync(helperSrc)) return false;
+  const helperDst = path.join(targetPluginDir, "scripts", "helpers", "find-project-root.mjs");
+  fs.mkdirSync(path.dirname(helperDst), { recursive: true });
+  fs.copyFileSync(helperSrc, helperDst);
+  return true;
+}
+
 function writeHermesPluginArtifacts(targetDir) {
   if (!fs.existsSync(HERMES_PLUGIN_DIR)) return false;
   fs.writeFileSync(path.join(HERMES_PLUGIN_DIR, "xray-consumer-root.txt"), `${targetDir}\n`);
@@ -295,6 +304,7 @@ module.exports = {
   buildStdioMcpServer,
   buildPluginMcpJson,
   buildPortableProjectMcpJson,
+  copyHermesFindProjectRootHelper,
   writeHermesPluginArtifacts,
   syncHermesMcpRegistry,
   mergeOpencodeMcpRegistry,

package/scripts/node/install-bridges.cjs

@@ -13,23 +13,14 @@ const {
   wireOpencodeBridge,
   wireOpenClawBridge,
   deployPortableProjectMcpJson,
+  copyHermesFindProjectRootHelper,
+  XRAY_MCP_SERVERS,
 } = require("./bridge-mcp-wiring.cjs");
 
 const SKIP_DIRS = new Set(["node_modules", "logs"]);
 const MERGE_FILES = new Set(["enforcer-config.json"]);
 const KEEP_IF_EXISTS = new Set([".yml", ".yaml", ".md"]);
 
-/** Canonical 7-server MCP surface — matches package .mcp.json and Grok plugin */
-const XRAY_MCP_SERVERS = [
-  { name: "xray-governance", mcpCmd: "governance", env: { XRAY_FORCE_MCP_GOVERNANCE: "true" } },
-  { name: "xray-skills", mcpCmd: "skills", env: {} },
-  { name: "xray-orchestrator", mcpCmd: "orchestrator", env: {} },
-  { name: "xray-enforcer", mcpCmd: "enforcer", env: {} },
-  { name: "xray-researcher", mcpCmd: "researcher", env: {} },
-  { name: "xray-code-review", mcpCmd: "code-review", env: {} },
-  { name: "xray-architect-tools", mcpCmd: "architect-tools", env: {} },
-];
-
 function resolveConsumerTargetDir(packageRoot, fallbackDir) {
   const resolved = path.resolve(packageRoot);
   const inNodeModules =
@@ -335,6 +326,7 @@ function installHermesBridge(targetDir, packageRoot, log) {
       fs.copyFileSync(src, dst);
     }
   }
+  copyHermesFindProjectRootHelper(packageRoot, targetPluginDir);
   log("hermes-bridge", "plugin copied", "info", { path: "~/.hermes/plugins/xray-hermes" });
 
   writePluginMcpJson(targetPluginDir, targetDir, log, "hermes-bridge");

package/scripts/node/load-reflection-config.mjs

@@ -16,9 +16,9 @@ const root = process.env.PROJECT_ROOT || process.cwd();
 const configPath = join(root, '.xray', 'features.json');
 
 let mode = 'minimal';
-let commitThreshold = 25;
+let commitThreshold = 50;
 let daysThreshold = 14;
-let autoGenerate = true;
+let autoGenerate = false;
 let promptUser = true;
 
 if (existsSync(configPath)) {

package/scripts/node/release-gate.mjs

@@ -48,14 +48,18 @@ function main() {
         step("4/5 Consumer install smoke", "node scripts/node/consumer-install-smoke.mjs");
       }
     } else {
-      step("1/5 Build", "npm run build");
-      step("2/5 Tests", "npm test");
+      step("1/6 Build", "npm run build");
+      step("2/6 Tests", "npm test");
       step(
-        "3/5 Plugin infrastructure",
+        "3/6 Consumer hook verifiers",
+        "npm run verify:pre-commit-diff && npm run verify:pre-push-diff && node scripts/mjs/verify-delegation-gate-core.mjs --host=grok && node scripts/mjs/verify-delegation-gate-core.mjs --host=hermes && node scripts/mjs/verify-hermes-session-start.mjs && node scripts/mjs/verify-confer-core.mjs && npm run verify:user-aside && npm run build && node scripts/mjs/verify-pipeline-facets.mjs --package-only",
+      );
+      step(
+        "4/6 Plugin infrastructure",
         "node scripts/test/validate-plugins-e2e.cjs --structural-only",
       );
       if (!skipSmoke) {
-        step("4/5 Consumer install smoke (fresh + upgrade)", "node scripts/node/consumer-install-smoke.mjs");
+        step("5/6 Consumer install smoke (fresh + upgrade)", "node scripts/node/consumer-install-smoke.mjs");
       }
     }
 

package/src/mcps/architect-tools.server.ts

@@ -235,16 +235,21 @@ class XrayArchitectToolsServer extends XrayKnowledgeSkillBase {
   private async architectureAssessment(args: Record<string, unknown> | undefined) {
     const projectRoot = (args?.projectRoot as string) || "";
     const assessmentType = (args?.assessmentType as "quick" | "comprehensive") || "comprehensive";
+    const conferPrompt = typeof args?.conferPrompt === "string" ? args.conferPrompt : "";
 
     frameworkLogger.log("mcps/architect-tools", "architecture-assessment", "info", { projectRoot });
 
     const result = await architectArchitectureAssessment(projectRoot, assessmentType);
+    const assessmentJson = JSON.stringify(result, null, 2);
+    const text = conferPrompt.trim()
+      ? `${conferPrompt.trim()}\n\n## Architecture assessment\n${assessmentJson}\n\nVerdict: CONDITIONAL\nTop risks: review assessment metrics above\nHardening: address high-complexity or coupling findings before resuming`
+      : assessmentJson;
 
     return {
       content: [
         {
           type: "text",
-          text: JSON.stringify(result, null, 2),
+          text,
         },
       ],
     };

package/src/mcps/orchestrator/handlers/complexity-handler.ts

@@ -11,8 +11,27 @@ import {
   isLeadDevModeActive,
   persistLeadDevPlan,
 } from '../../../nucleus/autonomy-kernel.js';
+import {
+  formatConferQuorumReport,
+  isConferEnabled,
+  runConferQuorum,
+} from '../../../nucleus/confer.js';
 import { bindPlanToSession } from '../../../nucleus/lead-dev-plan-persistence.js';
 import { clearPendingDelegations } from '../../../nucleus/pending-delegations.js';
+import {
+  isAutoProvisionWorktreeEnabled,
+  provisionGitWorktree,
+} from '../../../nucleus/aside-worktree.js';
+import {
+  buildUserAsidePlan,
+  formatUserAsideSummary,
+  isUserAsidesEnabled,
+  loadUserAside,
+  mergeUserAsideIntake,
+  saveUserAside,
+  setActiveAsideId,
+  UserAsideValidationError,
+} from '../../../nucleus/user-aside.js';
 import { getExecutionPlanner } from '../execution/execution-planner.js';
 import { addObservations, extractComplexityObservations } from '../aside-context.js';
 import type { OrchestrationTask, ComplexityAnalysis } from '../types.js';
@@ -73,6 +92,13 @@ export class ComplexityHandler {
       sessionId?: string;
       synthesisCheckpoint?: boolean;
       synthesisDueReason?: string | null;
+      collocatedText?: string | null;
+      conferFixture?: boolean;
+      userAsideId?: string;
+      userAsideTitle?: string;
+      worktree?: string;
+      branch?: string;
+      setActiveAside?: boolean;
     },
     asideId?: string,
   ): Promise<{ content: Array<{ type: string; text: string }>; ok: boolean }> {
@@ -99,20 +125,120 @@ export class ComplexityHandler {
         .filter((t) => t.description?.trim())
         .map((t) => ({ description: t.description, type: t.type }));
       const synthesisCheckpoint = args.synthesisCheckpoint === true;
-      const leadDevPlan = synthesisCheckpoint
+      const projectRoot = process.cwd();
+      const userAsideIntake =
+        !synthesisCheckpoint &&
+        Boolean(args.userAsideId?.trim()) &&
+        isUserAsidesEnabled(projectRoot);
+
+      let userAsideReport = '';
+      let leadDevPlan = synthesisCheckpoint
         ? buildSynthesisCheckpointPlan(args.synthesisDueReason ?? null)
-        : isLeadDevModeActive() && (primaryDescription || planTaskInputs.length > 0)
-          ? buildLeadDevPlan(
-              primaryDescription,
-              taskTypes.length ? taskTypes : ['implement'],
-              planTaskInputs,
-              analysis.overallComplexity,
-            )
-          : null;
-
-      let planPersisted = synthesisCheckpoint ? leadDevPlan !== null : !leadDevPlan;
-
-      if (leadDevPlan) {
+        : userAsideIntake
+          ? null
+          : isLeadDevModeActive() && (primaryDescription || planTaskInputs.length > 0)
+            ? buildLeadDevPlan(
+                primaryDescription,
+                taskTypes.length ? taskTypes : ['implement'],
+                planTaskInputs,
+                analysis.overallComplexity,
+              )
+            : null;
+
+      let planPersisted = synthesisCheckpoint
+        ? leadDevPlan !== null
+        : userAsideIntake
+          ? false
+          : !leadDevPlan;
+
+      if (userAsideIntake && args.userAsideId) {
+        try {
+          const asideId = args.userAsideId.trim();
+          const title = args.userAsideTitle?.trim() || asideId;
+          const existing = loadUserAside(asideId, projectRoot);
+          const userAside = existing
+            ? mergeUserAsideIntake(
+                existing,
+                primaryDescription || existing.description,
+                planTaskInputs,
+                analysis.overallComplexity,
+                projectRoot,
+              )
+            : buildUserAsidePlan(
+                asideId,
+                title,
+                primaryDescription || title,
+                planTaskInputs,
+                analysis.overallComplexity,
+                projectRoot,
+              );
+          if (!userAside) {
+            planPersisted = false;
+          } else {
+            if (args.worktree) userAside.worktree = args.worktree;
+            if (args.branch) userAside.branch = args.branch;
+            if (args.sessionId) userAside.sessionId = args.sessionId;
+            if (args.userAsideTitle) userAside.title = title;
+
+            let worktreeProvisionNote = '';
+            if (
+              args.worktree?.trim() &&
+              args.branch?.trim() &&
+              isAutoProvisionWorktreeEnabled(projectRoot)
+            ) {
+              const provision = provisionGitWorktree({
+                projectRoot,
+                worktree: args.worktree.trim(),
+                branch: args.branch.trim(),
+              });
+              if (!provision.ok) {
+                throw new UserAsideValidationError(
+                  `Worktree auto-provision failed: ${provision.message}`,
+                );
+              }
+              worktreeProvisionNote = provision.created
+                ? `\n\n**Worktree provisioned:** \`${provision.path}\` (branch \`${args.branch.trim()}\`)`
+                : `\n\n**Worktree ready:** \`${provision.path}\``;
+            }
+
+            const asidePath = saveUserAside(userAside, projectRoot);
+            const activate = args.setActiveAside !== false;
+            if (activate) {
+              clearPendingDelegations(projectRoot);
+              setActiveAsideId(asideId, projectRoot, args.sessionId ?? null);
+            }
+            planPersisted = true;
+            userAsideReport = `\n\n## User aside\n\n${formatUserAsideSummary(userAside)}${worktreeProvisionNote}`;
+            if (activate) {
+              userAsideReport += `\n\n**Active aside:** \`${asideId}\` — spawns route to \`${asideId}.a.*\` todos.`;
+            }
+            await frameworkLogger.log(
+              'orchestrator.server',
+              'user-aside-persisted',
+              'info',
+              {
+                asidePath,
+                asideId,
+                todoCount: userAside.plan.phases.reduce((n, p) => n + p.todos.length, 0),
+                activated: activate,
+              },
+            );
+          }
+        } catch (err) {
+          planPersisted = false;
+          const message = err instanceof Error ? err.message : String(err);
+          userAsideReport = `\n\n❌ User aside intake failed: ${message}`;
+          await frameworkLogger.log(
+            'orchestrator.server',
+            'user-aside-persist-failed',
+            'warning',
+            {
+              error: message,
+              validation: err instanceof UserAsideValidationError,
+            },
+          );
+        }
+      } else if (leadDevPlan) {
         try {
           const sessionId = args.sessionId ?? `analyze-${Date.now()}`;
           if (!synthesisCheckpoint) {
@@ -145,6 +271,37 @@ export class ComplexityHandler {
         }
       }
 
+      let conferReport = '';
+      if (
+        synthesisCheckpoint &&
+        leadDevPlan &&
+        planPersisted &&
+        isConferEnabled() &&
+        args.sessionId
+      ) {
+        const conferOpts: {
+          dueReason?: string | null;
+          fixture?: boolean;
+          collocatedText?: string;
+        } = {
+          dueReason: args.synthesisDueReason ?? null,
+          fixture: args.conferFixture === true,
+        };
+        if (args.collocatedText) conferOpts.collocatedText = args.collocatedText;
+        const conferResult = await runConferQuorum(process.cwd(), args.sessionId, conferOpts);
+        conferReport = `\n\n${formatConferQuorumReport(conferResult)}`;
+        await frameworkLogger.log(
+          'orchestrator.server',
+          'confer-quorum',
+          conferResult.status === 'completed' ? 'info' : 'warning',
+          {
+            status: conferResult.status,
+            agentCount: conferResult.agents.length,
+            sessionId: args.sessionId,
+          },
+        );
+      }
+
       const ok = planPersisted;
 
       return {
@@ -152,13 +309,14 @@ export class ComplexityHandler {
         content: [
           {
             type: 'text',
-            text: this.formatComplexityResponse(
-              analysis,
-              recommendations,
-              tasks.length,
-              leadDevPlan,
-              synthesisCheckpoint,
-            ),
+            text:
+              this.formatComplexityResponse(
+                analysis,
+                recommendations,
+                tasks.length,
+                leadDevPlan,
+                synthesisCheckpoint,
+              ) + conferReport + userAsideReport,
           },
         ],
       };

package/src/mcps/orchestrator/handlers/task-handler.ts

@@ -47,9 +47,108 @@ export class TaskHandler {
       sessionId?: string;
       executionMode?: string;
       timeout?: number;
+      confer?: boolean;
+      conferFixture?: boolean;
+      collocatedText?: string;
+      userAsideId?: string;
+      setActiveAside?: boolean;
+      clearActiveAside?: boolean;
     },
     deps: TaskHandlerDeps
   ): Promise<{ content: Array<{ type: string; text: string }> }> {
+    if (args.clearActiveAside === true) {
+      const projectRoot = process.cwd();
+      const { clearActiveAside, getActiveAsideId } = await import(
+        '../../../nucleus/user-aside.js',
+      );
+      const prior = getActiveAsideId(projectRoot, args.sessionId ?? null);
+      clearActiveAside(projectRoot);
+      return {
+        content: [
+          {
+            type: 'text',
+            text: prior
+              ? `✅ Cleared active aside \`${prior}\` — spawns resume main lead-dev plan.`
+              : 'ℹ️ No active aside was set.',
+          },
+        ],
+      };
+    }
+
+    if (args.userAsideId?.trim()) {
+      const projectRoot = process.cwd();
+      const {
+        setActiveAsideId,
+        loadUserAside,
+        formatUserAsideSummary,
+        isUserAsidesEnabled,
+        UserAsideValidationError,
+      } = await import('../../../nucleus/user-aside.js');
+      const { clearPendingDelegations } = await import(
+        '../../../nucleus/pending-delegations.js',
+      );
+      if (!isUserAsidesEnabled(projectRoot)) {
+        return {
+          content: [{ type: 'text', text: '❌ User asides disabled in features.json' }],
+        };
+      }
+      const asideId = args.userAsideId.trim();
+      const aside = loadUserAside(asideId, projectRoot);
+      if (!aside) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `❌ User aside \`${asideId}\` not found — run analyze-complexity with userAsideId first.`,
+            },
+          ],
+        };
+      }
+      if (args.setActiveAside !== false) {
+        try {
+          clearPendingDelegations(projectRoot);
+          setActiveAsideId(asideId, projectRoot, args.sessionId ?? null);
+        } catch (err) {
+          const message = err instanceof UserAsideValidationError ? err.message : String(err);
+          return { content: [{ type: 'text', text: `❌ ${message}` }] };
+        }
+      }
+      return {
+        content: [
+          {
+            type: 'text',
+            text:
+              `✅ Active aside: \`${asideId}\`\n\n${formatUserAsideSummary(aside)}`,
+          },
+        ],
+      };
+    }
+
+    if (args.confer === true) {
+      const { runConferQuorum, formatConferQuorumReport, isConferEnabled } = await import(
+        '../../../nucleus/confer.js',
+      );
+      const sid = args.sessionId ?? `confer_${Date.now()}`;
+      if (!isConferEnabled()) {
+        return {
+          content: [{ type: 'text', text: '❌ Confer disabled in features.json' }],
+        };
+      }
+      const conferOpts: {
+        dueReason?: string | null;
+        fixture?: boolean;
+        collocatedText?: string;
+      } = {
+        dueReason: args.description,
+        fixture: args.conferFixture === true,
+      };
+      if (args.collocatedText) conferOpts.collocatedText = args.collocatedText;
+      const result = await runConferQuorum(process.cwd(), sid, conferOpts);
+      return {
+        content: [{ type: 'text', text: formatConferQuorumReport(result) }],
+      };
+    }
+
     const { description, tasks = [], sessionId = `session_${Date.now()}`, executionMode = 'optimized', timeout = 300000 } = args;
 
     await frameworkLogger.log(