@geraldmaron/construct 1.2.2 → 1.3.0

package/lib/headhunt.mjs

@@ -13,15 +13,19 @@ import os from 'node:os';
 import path from 'node:path';
 import { createInterface } from 'node:readline';
 import { selectOption } from './tty-prompts.mjs';
+import { resolveActiveScope } from './scopes/loader.mjs';
+import { classifyObjectiveForScope } from './scopes/teams.mjs';
+import { loadRegistry } from './registry/loader.mjs';
 
 const OVERLAY_DIRNAME = 'domain-overlays';
 const PROMOTION_DIRNAME = 'promotion-requests';
-const TEAMS_FILE = 'specialists/teams.json';
 
 function loadTeamTemplates(root) {
   try {
-    const teamsPath = path.join(root, TEAMS_FILE);
-    return JSON.parse(fs.readFileSync(teamsPath, 'utf8'));
+    const registry = loadRegistry({ rootDir: root });
+    return {
+      templates: registry.teams || {},
+    };
   } catch {
     return null;
   }
@@ -63,37 +67,70 @@ function promptQuestion(rl, question) {
   return new Promise((resolve) => rl.question(question, resolve));
 }
 
-function classifyOverlay(objective = '', explicitTeam = '') {
+export function classifyOverlay(objective = '', explicitTeam = '', { cwd = process.cwd() } = {}) {
   if (explicitTeam) {
     return {
       focus: 'custom',
       attachTo: explicitTeam.split(',').map((value) => value.trim()).filter(Boolean),
+      teamFocus: 'custom-team',
     };
   }
 
+  const profile = resolveActiveScope(cwd);
+  const profileMatch = classifyObjectiveForScope(objective, profile);
+  if (profileMatch) return profileMatch;
+
   const text = objective.toLowerCase();
+  
+  // NEW: Team-first classification returns both team id and specialist roles
   if (/security|policy|compliance|secrets|iam|threat|audit/.test(text)) {
-    return { focus: 'security', attachTo: ['cx-security', 'cx-architect'] };
+    return {
+      focus: 'security',
+      attachTo: ['cx-security', 'cx-architect'],
+      teamFocus: 'governance-group',
+      recommendedTeam: 'governance-group',
+    };
   }
   if (/implement|build|module|deploy|pipeline|ci\/cd|apply|code/.test(text)) {
-    return { focus: 'implementation', attachTo: ['cx-engineer', 'cx-architect'] };
+    return {
+      focus: 'implementation',
+      attachTo: ['cx-engineer', 'cx-architect'],
+      teamFocus: 'engineering-group',
+      recommendedTeam: 'engineering-group',
+    };
   }
   if (/runbook|docs|documentation|guide|onboard/.test(text)) {
-    return { focus: 'documentation', attachTo: ['cx-docs-keeper', 'cx-researcher'] };
+    return {
+      focus: 'documentation',
+      attachTo: ['cx-docs-keeper', 'cx-researcher'],
+      teamFocus: 'operations-group',
+      recommendedTeam: 'operations-group',
+    };
   }
   if (/research|compare|recent|latest|best practices|upgrade|migration/.test(text)) {
-    return { focus: 'research', attachTo: ['cx-researcher', 'cx-architect'] };
+    return {
+      focus: 'research',
+      attachTo: ['cx-researcher', 'cx-architect'],
+      teamFocus: 'strategy-group',
+      recommendedTeam: 'strategy-group',
+    };
   }
-  return { focus: 'architecture', attachTo: ['cx-architect', 'cx-researcher'] };
+  return {
+    focus: 'architecture',
+    attachTo: ['cx-architect', 'cx-researcher'],
+    teamFocus: 'engineering-group',
+    recommendedTeam: 'engineering-group',
+  };
 }
 
-function buildOverlayPrompt({ domain, objective, scope, permanence, focus, freshness }) {
+function buildOverlayPrompt({ domain, objective, scope, permanence, focus, freshness, teamFocus = '' }) {
   return [
     `Domain overlay: ${domain}`,
     `Objective: ${objective}`,
     scope ? `Scope: ${scope}` : null,
     `Permanence: ${permanence}`,
     `Primary focus: ${focus}`,
+    teamFocus ? `Team focus: ${teamFocus}` : null,
     `Freshness requirement: ${freshness}`,
     'Rules:',
     '- Treat this as an internal Construct overlay, not a permanent public role.',
@@ -102,6 +139,7 @@ function buildOverlayPrompt({ domain, objective, scope, permanence, focus, fresh
     '- Separate confirmed facts from inference.',
     '- Respect existing Construct workflow, security, and validation boundaries.',
     '- Do not broaden tool permissions just because the domain is specialized.',
+    '- NEW: Team-first approach — work within the team structure and escalation paths defined in your organization.',
   ].filter(Boolean).join('\n');
 }
 
@@ -342,7 +380,7 @@ export async function runHeadhunt({ args = [], cwd = process.cwd(), homeDir = os
     if (!templateName) { listTeamTemplates(cwd); return; }
     const root = findConstructRoot(cwd);
     const teams = loadTeamTemplates(root);
-    if (!teams) throw new Error('specialists/teams.json not found. Run from the Construct root.');
+     if (!teams) throw new Error('specialists/org not found. Run from the Construct root.');
     const tpl = teams.templates[templateName];
     if (!tpl) throw new Error(`Unknown template: ${templateName}. Run 'construct headhunt template' to list available templates.`);
     const objective = typeof flags.for === 'string' ? flags.for.trim() : rest.slice(1).join(' ').trim();
@@ -354,29 +392,30 @@ export async function runHeadhunt({ args = [], cwd = process.cwd(), homeDir = os
     const overlayDir = getOverlayDir(root);
     const expiresAt = permanence === 'temporary' ? new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000).toISOString() : null;
 
-    const overlay = {
-      id: overlayId,
-      type: 'domain-overlay',
-      domain: templateName,
-      objective,
-      scope: typeof flags.scope === 'string' ? flags.scope.trim() : null,
-      permanence,
-      focus: tpl.focus,
-      attachTo: tpl.members,
-      freshness,
-      teamTemplate: templateName,
-      teamId: overlayId,
-      createdAt: now.toISOString(),
-      expiresAt,
-      project: path.basename(root),
-      workflowId: null,
-      taskKey: null,
-      status: 'active',
-      prompt: buildOverlayPrompt({ domain: templateName, objective, scope: typeof flags.scope === 'string' ? flags.scope : '', permanence, focus: tpl.focus, freshness }),
-      skills: tpl.skills ?? [],
-      promotionGates: tpl.promotionGates ?? buildPromotionGates(),
-      challenge: null,
-    };
+     const overlay = {
+       id: overlayId,
+       type: 'domain-overlay',
+       domain: templateName,
+       objective,
+       scope: typeof flags.scope === 'string' ? flags.scope.trim() : null,
+       permanence,
+       focus: tpl.focus,
+       attachTo: tpl.members,
+       freshness,
+       teamTemplate: templateName,
+       teamId: overlayId,
+       teamFocus: tpl.focus,
+       createdAt: now.toISOString(),
+       expiresAt,
+       project: path.basename(root),
+       workflowId: null,
+       taskKey: null,
+       status: 'active',
+       prompt: buildOverlayPrompt({ domain: templateName, objective, scope: typeof flags.scope === 'string' ? flags.scope : '', permanence, focus: tpl.focus, freshness, teamFocus: tpl.focus }),
+       skills: tpl.skills ?? [],
+       promotionGates: tpl.promotionGates ?? buildPromotionGates(),
+       challenge: null,
+     };
 
     const overlayJsonPath = path.join(overlayDir, `${overlayId}.json`);
     const overlayMdPath = path.join(overlayDir, `${overlayId}.md`);
@@ -448,7 +487,11 @@ export async function runHeadhunt({ args = [], cwd = process.cwd(), homeDir = os
     }
 
     const freshness = typeof flags.freshness === 'string' ? flags.freshness : 'current';
-    const classification = classifyOverlay(objective, typeof flags.team === 'string' ? flags.team : '');
+    const classification = classifyOverlay(
+      objective,
+      typeof flags.team === 'string' ? flags.team : '',
+      { cwd },
+    );
     const now = new Date();
     const root = findConstructRoot(cwd);
     const overlayId = `${slugify(domain)}-${now.toISOString().replace(/[:.]/g, '-')}`;
@@ -473,6 +516,9 @@ export async function runHeadhunt({ args = [], cwd = process.cwd(), homeDir = os
       taskKey: null,
       status: permanence === 'temporary' ? 'active' : 'promotion_requested',
       teamId: overlayId,
+      teamFocus: classification.teamFocus || classification.focus,
+      recommendedTeam: classification.recommendedTeam || null,
+      scopeTeamSource: classification.scopeTeamSource || null,
       sourceStrategy: [
         'official docs',
         'release notes/changelogs',
@@ -488,6 +534,7 @@ export async function runHeadhunt({ args = [], cwd = process.cwd(), homeDir = os
         permanence,
         focus: classification.focus,
         freshness,
+        teamFocus: classification.teamFocus,
       }),
       promotionGates: buildPromotionGates(),
       challenge: permanence === 'temporary' ? null : {

package/lib/hooks/agent-tracker.mjs

@@ -155,10 +155,10 @@ try {
     if (success !== null) {
       try {
         const { recordOutcome } = await import('../outcomes/record.mjs');
-        const { resolveActiveProfile } = await import('../profiles/loader.mjs');
+        const { resolveActiveScope } = await import('../scopes/loader.mjs');
         const roleId = agentName.replace(/^cx-/, '');
         const projectCwd = input?.cwd || process.cwd();
-        const activeProfile = resolveActiveProfile(projectCwd);
+        const activeProfile = resolveActiveScope(projectCwd);
         recordOutcome(projectCwd, {
           role: roleId,
           success,

package/lib/hooks/config-protection.mjs

@@ -52,7 +52,7 @@ const PROTECTED = [
 ];
 
 const META_FILES = [
-  /(?:^|\/)specialists\/registry\.json$/,
+  /(?:^|\/)specialists\/org(?:\/|$)/,
   /(?:^|\/)lib\/setup\.mjs$/,
   /(?:^|\/)bin\/construct-postinstall\.mjs$/,
   /(?:^|\/)claude\/settings\.template\.json$/,

package/lib/hooks/registry-sync.mjs

@@ -3,11 +3,11 @@
  * lib/hooks/registry-sync.mjs — Registry-change reminder hook.
  *
  * PostToolUse on Write|Edit. Fires only when the edited file is
- * specialists/registry.json (the construct repo) or an installed
+ * specialists/org/ (the construct repo) or an installed
  * agents/registry.json mirror. Emits a one-line reminder on stderr telling
  * the developer to run `construct sync` when they're ready. Does NOT
  * auto-execute sync — auto-execution during tests (which legitimately
- * mutate registry.json) races test cleanup and regenerates platform state
+ * mutate the registry) races test cleanup and regenerates platform state
  * mid-suite. The dev decides when to sync, the same way ordinary code
  * changes don't auto-build.
  *
@@ -30,7 +30,7 @@ const input = readHookInput();
 const filePath = input?.tool_input?.file_path || process.env.TOOL_INPUT_FILE_PATH || '';
 const matchesRegistry =
   filePath.endsWith(path.join('agents', 'registry.json')) ||
-  filePath.endsWith('/specialists/registry.json');
+  filePath.includes(`${path.sep}specialists${path.sep}org`);
 if (!matchesRegistry) process.exit(0);
 
 const isNonInteractive =

package/lib/host-capabilities.mjs

@@ -153,7 +153,7 @@ export function detectActiveSessions() {
 //                       dispatch or config-driven agents): Claude Code, OpenCode.
 //   mcp-orchestrated  — no native subagent primitive, but the host calls the
 //                       `orchestration_run` MCP tool to reach the same orchestrated
-//                       outcome via the daemon: Codex, VS Code, Cursor, Copilot.
+//                       outcome in-process: Codex, VS Code, Cursor, Copilot.
 //   prompt-only       — neither native dispatch nor MCP; instruction files only.
 //                       No supported 2026 host is prompt-only.
 
@@ -211,7 +211,7 @@ export function detectHostCapabilities() {
       sharedTaskRuntime: "tracker-plus-plan",
       lifecycleHooks: [],
       notes: [
-        "Run a full multi-specialist chain via the `orchestration_run` MCP tool (start `construct dashboard`).",
+        "Run a full multi-specialist chain via the `orchestration_run` MCP tool (in-process; no daemon needed).",
         "Use Construct profiles, MCP project/memory tools, and the active session for single-pass work.",
       ],
     },
@@ -225,7 +225,7 @@ export function detectHostCapabilities() {
       sharedTaskRuntime: "editor-session",
       lifecycleHooks: [],
       notes: [
-        "Run a full multi-specialist chain via the `orchestration_run` MCP tool in Copilot agent mode (start `construct dashboard`).",
+        "Run a full multi-specialist chain via the `orchestration_run` MCP tool in Copilot agent mode (in-process; no daemon needed).",
         "Construct's MCP servers load from `.vscode/mcp.json` (project) and the user-profile `mcp.json` (global, only when it already exists).",
       ],
     },
@@ -239,7 +239,7 @@ export function detectHostCapabilities() {
       sharedTaskRuntime: "editor-session",
       lifecycleHooks: [],
       notes: [
-        "Run a full multi-specialist chain via the `orchestration_run` MCP tool (start `construct dashboard`).",
+        "Run a full multi-specialist chain via the `orchestration_run` MCP tool (in-process; no daemon needed).",
         "Construct manages Cursor MCP registrations in `.cursor/mcp.json` (project) and `~/.cursor/mcp.json` (global, when it already exists).",
       ],
     },
@@ -253,7 +253,7 @@ export function detectHostCapabilities() {
       sharedTaskRuntime: "editor-session",
       lifecycleHooks: [],
       notes: [
-        "Copilot agent mode runs Construct's MCP tools — use `orchestration_run` for a real multi-specialist chain (start `construct dashboard`).",
+        "Copilot agent mode runs Construct's MCP tools — use `orchestration_run` for a real multi-specialist chain (in-process; no daemon needed).",
         "Construct also writes reusable prompt profiles under `.github/prompts/` for single-pass role work.",
       ],
     },

package/lib/improvement/controller.mjs

@@ -4,7 +4,7 @@
  *
  * The controller is the mutation boundary for the governed loop. It admits only
  * versioned artifacts — proposal objects, dataset items, and evaluation reports,
- * never raw chat history — and refuses any candidate that lacks provenance,
+ * never raw unversioned session history — and refuses any candidate that lacks provenance,
  * lacks held-out evaluation evidence, failed a deterministic gate, names an unknown
  * approver, or has an unresolved dependency. Promotability is re-derived from the
  * report's own gate results rather than a precomputed flag, so a tampered decision
@@ -22,7 +22,7 @@ function isVersioned(artifact) {
 
 /**
  * Admit the input artifacts. Only versioned proposal/dataset/evaluation objects are
- * accepted; an unversioned blob (such as raw chat history) is refused
+ * accepted; an unversioned blob (such as raw session history) is refused
  * (construct-6zga.1.5 AC1).
  */
 export function admitArtifacts({ proposal = null, dataset = null, evaluationReport = null } = {}) {

package/lib/init-unified.mjs

@@ -69,11 +69,11 @@ const commitBootstrap = args.includes("--commit-bootstrap");
 const withHostFlags = new Set(HOST_KEYS.filter((k) => args.includes(`--with-${k}`)));
 const allHosts = args.includes("--all-hosts");
 
-// Active profile selector. `--profile=<id>` writes the field into the
-// project's construct.config.json so resolveActiveProfile picks it up
+// Active scope selector. `--scope=<id>` writes the field into the
+// project's construct.config.json so resolveActiveScope picks it up
 // on first run. Unknown ids are rejected with the available catalog.
-const profileArg = args.find((arg) => arg.startsWith("--profile="));
-const profileId = profileArg ? profileArg.split("=")[1] : null;
+const scopeArg = args.find((arg) => arg.startsWith("--scope="));
+const scopeId = scopeArg ? scopeArg.split("=")[1] : null;
 
 const created = [];
 const skipped = [];
@@ -745,10 +745,10 @@ async function main() {
     const { findProjectConfigPath, loadProjectConfig, writeProjectConfig, PROJECT_CONFIG_FILENAME } = await import('./config/project-config.mjs');
     const { DEFAULT_PROJECT_CONFIG } = await import('./config/schema.mjs');
 
-    if (profileId) {
-      const { loadProfile, listProfiles } = await import('./profiles/loader.mjs');
-      if (!loadProfile(profileId)) {
-        console.error(`Unknown profile: ${profileId}. Available: ${listProfiles().join(', ')}`);
+    if (scopeId) {
+      const { loadScope, listScopes } = await import('./scopes/loader.mjs');
+      if (!loadScope(scopeId)) {
+        console.error(`Unknown scope: ${scopeId}. Available: ${listScopes().join(', ')}`);
         process.exit(1);
       }
     }
@@ -763,29 +763,29 @@ async function main() {
       const cfg = {
         $schema: "./node_modules/@geraldmaron/construct/schemas/project-config.schema.json",
         ...DEFAULT_PROJECT_CONFIG,
-        profile: profileId || 'rnd',
+        scope: scopeId || 'rnd',
       };
       // Explicitly write the full default config object so all options are
       // visible and discoverable to the user in the file. The $schema property
       // provides inline documentation and validation in supported editors.
       writeProjectConfig(cfgPath, cfg, { validate: true, silent: true });
       created.push(PROJECT_CONFIG_FILENAME);
-      if (!quiet && profileId) console.log(`Profile set to ${profileId}.`);
-    } else if (profileId) {
+      if (!quiet && scopeId) console.log(`Scope set to ${scopeId}.`);
+    } else if (scopeId) {
       const loaded = loadProjectConfig(target);
       const cfg = loaded?.raw ? { ...loaded.raw } : { version: 1 };
-      cfg.profile = profileId;
+      cfg.scope = scopeId;
       writeProjectConfig(cfgPath, cfg, { validate: true, silent: true });
-      if (!quiet) console.log(`Profile set to ${profileId}.`);
+      if (!quiet) console.log(`Scope set to ${scopeId}.`);
     }
   }
 
-  // Resolve active profile to drive capability-gated scaffolding (intake
-  // archetype, attribution stamping). Falls back to rnd when no profile is
-  // configured — matches resolveActiveProfile semantics elsewhere.
+  // Resolve active scope to drive capability-gated scaffolding (intake
+  // archetype, attribution stamping). Falls back to rnd when no scope is
+  // configured — matches resolveActiveScope semantics elsewhere.
 
-  const { resolveActiveProfile } = await import('./profiles/loader.mjs');
-  const activeProfile = resolveActiveProfile(target, profileId) ?? null;
+  const { resolveActiveScope } = await import('./scopes/loader.mjs');
+  const activeProfile = resolveActiveScope(target, scopeId) ?? null;
   const intakeCap = activeProfile?.capabilities?.intake ?? null;
   const { gatherAttribution } = await import('./intake/attribution.mjs');
   const attribution = intakeCap?.attribution ? gatherAttribution() : null;
@@ -1228,12 +1228,10 @@ async function main() {
       
       if (!quiet) {
         console.log('\nServices:');
-        let dashboardUrl = null;
         for (const svc of results) {
           if (svc.status === 'started' || svc.status === 'reused') {
             const status = svc.status === 'reused' ? ' (running)' : '';
             console.log(`  ${svc.name}${status}${svc.url ? ` ${svc.url}` : ''}`);
-            if (svc.name === 'Dashboard' && svc.url) dashboardUrl = svc.url;
           } else if (svc.status === 'failed') {
             console.log(`  ${svc.name} — failed${svc.note ? ` (${svc.note})` : ''}`);
           }
@@ -1241,7 +1239,7 @@ async function main() {
 
         const telemetrySvc = results.find(r => r.name === 'Telemetry' && r.url?.includes('localhost'));
         if (telemetrySvc) console.log(`\nTelemetry: ${telemetrySvc.url}`);
-        if (dashboardUrl) console.log(`\nDashboard: ${dashboardUrl}  ·  stop services with \`construct stop\``);
+        console.log('\nStop services with `construct stop`');
       }
     } catch (error) {
       console.error(`Services could not be started: ${error.message}`);

package/lib/intake/classify.mjs

@@ -34,6 +34,11 @@
  */
 
 import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
 
 // Backward-compatible exports. RND defaults preserve the symbol surface
 // referenced by intake-config, prepare, and existing tests.
@@ -72,6 +77,22 @@ const TABLES = {
   research: researchTable,
 };
 
+const dynamicTableCache = new Map();
+
+function loadClassificationTable(tableRef) {
+  if (!tableRef || typeof tableRef !== 'string') return null;
+  if (dynamicTableCache.has(tableRef)) return dynamicTableCache.get(tableRef);
+  const abs = path.isAbsolute(tableRef) ? tableRef : path.join(REPO_ROOT, tableRef);
+  try {
+    const mod = require(abs);
+    const table = mod.default ?? mod;
+    dynamicTableCache.set(tableRef, table);
+    return table;
+  } catch {
+    return null;
+  }
+}
+
 // Filename patterns are explicit author-intent signals. The boost remains
 // at +0.4 so a clear keyword majority can still override (a postmortem
 // genuinely about a CVE escalation routes to security, not incident).
@@ -167,6 +188,11 @@ function matcherFor(entry) {
 function resolveTable(profile) {
   if (!profile) return rndTable;
   const id = typeof profile === 'string' ? profile : profile.id;
+  const tableRef = typeof profile === 'object' ? profile?.intake?.classificationTable : null;
+  if (typeof tableRef === 'string') {
+    const fromPath = loadClassificationTable(tableRef);
+    if (fromPath) return fromPath;
+  }
   return TABLES[id] || rndTable;
 }
 

package/lib/intake/daemon.mjs

@@ -19,14 +19,13 @@ import { join, basename } from 'node:path';
 
 import { createDaemon, classifyPacket } from '../daemons/contract.mjs';
 import { memoryCapMbFor } from '../resources/process-budget.mjs';
-import { stateDir } from '../config/xdg.mjs';
 
 const KILLSWITCH_ENV = 'CONSTRUCT_INTAKE_DAEMON';
 
 function inboxDir(cwd) { return join(cwd, 'inbox'); }
 function pendingDir(cwd) { return join(cwd, '.cx', 'intake', 'pending'); }
 function deadLetterDir(cwd) { return join(cwd, '.cx', 'intake', 'dead-letter'); }
-function heartbeatPath() { return join(stateDir(), 'intake-daemon.heartbeat'); }
+function heartbeatPath(cwd) { return join(cwd, '.cx', 'runtime', 'intake-daemon.heartbeat'); }
 
 function ensureDir(dir) {
   try { mkdirSync(dir, { recursive: true }); } catch { /* ignore */ }
@@ -128,7 +127,7 @@ export function buildIntakeDaemon({ cwd = process.cwd(), intervalMs = 60_000, cl
     name: 'intake',
     intervalMs,
     killswitchEnv: KILLSWITCH_ENV,
-    heartbeatPath: heartbeatPath(),
+    heartbeatPath: heartbeatPath(cwd),
     maxRuntimeMs: 24 * 60 * 60 * 1000,
     maxIdleTicks: 6,
     memoryCapMb: memoryCapMbFor('intake', cwd),

package/lib/intake/prepare.mjs

@@ -34,7 +34,8 @@ import { suggestDocsLaneForFile } from '../docs-routing.mjs';
 import { createIntakeQueue } from './queue.mjs';
 import { classifyRdIntake, suggestTags } from './classify.mjs';
 import { detectCustomerMentions, linkSignalToCustomer, updateCustomerProfile } from '../embed/customer-profiles.mjs';
-import { resolveActiveProfile } from '../profiles/loader.mjs';
+import { resolveActiveScope } from '../scopes/loader.mjs';
+import { resolveResearchProfile } from '../scopes/research-profile.mjs';
 import { emitBestEffort as emitRoleEvent } from '../roles/event-bus.mjs';
 import { gatherAttribution, stampAttribution } from './attribution.mjs';
 import { MANIFEST_REL_PATH } from './manifest.mjs';
@@ -91,13 +92,19 @@ export async function prepareIntakeForIngestedFile({
   // Resolve the active profile so non-RND projects route to their own table.
   // Falls back to rnd for any project without explicit configuration, which
   // preserves prior behavior for every existing user.
-  const activeProfile = resolveActiveProfile(rootDir);
-  const triage = classifyFn({
+  const activeProfile = resolveActiveScope(rootDir);
+  const classified = classifyFn({
     sourcePath: ingestedFile.sourcePath,
     extractedText: extracted,
     related,
     profile: activeProfile?.id,
   });
+  const researchProfile = resolveResearchProfile({
+    intakeType: classified?.intakeType,
+    artifactType: lane,
+    scope: activeProfile,
+  });
+  const triage = researchProfile ? { ...classified, researchProfile } : classified;
 
   // Detect customer mentions and update profiles
   const customerMentions = detectCustomerMentions(extracted.slice(0, 2000));

package/lib/intake/session-prelude.mjs

@@ -13,7 +13,7 @@
 import { createIntakeQueue } from './queue.mjs';
 import { formatTriageLine } from './classify.mjs';
 import { isBrokered } from '../mcp/broker.mjs';
-import { getRebrand } from '../profiles/rebrand.mjs';
+import { getRebrand } from '../scopes/rebrand.mjs';
 import { homedir as osHomedir } from 'node:os';
 import { readLastTick } from '../oracle/index.mjs';
 import { listPending } from '../oracle/actions.mjs';

package/lib/intake/tables/creative.mjs

@@ -11,8 +11,8 @@ export const STAGES = ['brief', 'research', 'draft', 'review', 'publish', 'measu
 export const UNKNOWN_TRIAGE = {
   intakeType: 'unknown',
   rdStage: 'unknown',
-  primaryOwner: 'operator',
-  recommendedChain: ['operator'],
+  primaryOwner: 'operations',
+  recommendedChain: ['operations'],
   recommendedAction: 'summarize',
   risk: 'low',
   requiresApproval: false,
@@ -33,8 +33,8 @@ export const CLASSIFICATION_TABLE = [
     intakeType: 'brief',
     keywords: ['brief', 'campaign', 'launch plan', 'go-to-market', 'gtm', 'positioning', 'narrative', 'audience'],
     rdStage: 'brief',
-    primaryOwner: 'product-lead',
-    recommendedChain: ['product-lead', 'researcher', 'content-writer'],
+    primaryOwner: 'product-manager',
+    recommendedChain: ['product-manager', 'researcher', 'docs-keeper'],
     recommendedAction: 'draft-prd',
     risk: 'medium',
     requiresApproval: false,
@@ -43,8 +43,8 @@ export const CLASSIFICATION_TABLE = [
     intakeType: 'content-request',
     keywords: ['blog', 'article', 'landing page', 'social post', 'newsletter', 'email copy', 'video script', 'headline', 'post', 'content'],
     rdStage: 'draft',
-    primaryOwner: 'content-writer',
-    recommendedChain: ['content-writer', 'reviewer'],
+    primaryOwner: 'docs-keeper',
+    recommendedChain: ['docs-keeper', 'reviewer'],
     recommendedAction: 'draft-rfc',
     risk: 'low',
     requiresApproval: false,
@@ -74,7 +74,7 @@ export const CLASSIFICATION_TABLE = [
     keywords: ['report', 'dashboard', 'attribution', 'ctr', 'cpa', 'roas', 'conversion', 'funnel', 'engagement'],
     rdStage: 'measure',
     primaryOwner: 'data-analyst',
-    recommendedChain: ['data-analyst', 'product-lead'],
+    recommendedChain: ['data-analyst', 'product-manager'],
     recommendedAction: 'evaluate',
     risk: 'low',
     requiresApproval: false,
@@ -83,8 +83,8 @@ export const CLASSIFICATION_TABLE = [
     intakeType: 'ops',
     keywords: ['process', 'workflow', 'template', 'sla', 'calendar', 'planning', 'editorial calendar'],
     rdStage: 'review',
-    primaryOwner: 'operator',
-    recommendedChain: ['operator', 'product-lead'],
+    primaryOwner: 'operations',
+    recommendedChain: ['operations', 'product-manager'],
     recommendedAction: 'create-runbook',
     risk: 'low',
     requiresApproval: false,

package/lib/intake/tables/operations.mjs

@@ -12,8 +12,8 @@ export const STAGES = ['request', 'triage', 'resolve', 'document', 'improve'];
 export const UNKNOWN_TRIAGE = {
   intakeType: 'unknown',
   rdStage: 'unknown',
-  primaryOwner: 'operator',
-  recommendedChain: ['operator'],
+  primaryOwner: 'operations',
+  recommendedChain: ['operations'],
   recommendedAction: 'summarize',
   risk: 'low',
   requiresApproval: false,
@@ -74,8 +74,8 @@ export const CLASSIFICATION_TABLE = [
     intakeType: 'request',
     keywords: ['request', 'access', 'feature request', 'integration', 'new tool', 'change request', 'how do i', 'can someone'],
     rdStage: 'triage',
-    primaryOwner: 'operator',
-    recommendedChain: ['operator', 'engineer'],
+    primaryOwner: 'operations',
+    recommendedChain: ['operations', 'engineer'],
     recommendedAction: 'clarify',
     risk: 'low',
     requiresApproval: false,

package/lib/intake/tables/research.mjs

@@ -74,8 +74,8 @@ export const CLASSIFICATION_TABLE = [
     intakeType: 'ops',
     keywords: ['process', 'methodology', 'template', 'protocol', 'consent form', 'data handling'],
     rdStage: 'gather',
-    primaryOwner: 'operator',
-    recommendedChain: ['operator', 'researcher'],
+    primaryOwner: 'operations',
+    recommendedChain: ['operations', 'researcher'],
     recommendedAction: 'create-runbook',
     risk: 'low',
     requiresApproval: false,