@geraldmaron/construct 1.0.4 → 1.0.5

package/lib/flavors/loader.mjs

@@ -0,0 +1,136 @@
+/**
+ * lib/flavors/loader.mjs — Role flavor overlay loader and validator.
+ *
+ * Reads frontmatter from skills/roles/<role>.<flavor>.md files, exposes:
+ *   - listFlavors(role?, profile?) — overlays that apply to role and profile
+ *   - validateFlavor(path) — frontmatter conformance check against the schema
+ *   - perRoleFlavorCount(profile) — flavor counts per role for cap enforcement
+ *
+ * The cap is enforced at sync time and in lint-prose's sibling lint-flavors.
+ * Six flavors per role per profile is the current ceiling; bumping requires
+ * an ADR. Existing roles like qa already have 6, so the cap is set tight.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(MODULE_DIR, '..', '..');
+const FLAVORS_DIR = path.join(REPO_ROOT, 'skills', 'roles');
+
+export const FLAVOR_CAP_PER_ROLE_PER_PROFILE = 6;
+
+// Files may start with an HTML comment block before the YAML frontmatter.
+// The /m flag lets ^ match line-start so we find the YAML wherever it sits.
+const FRONTMATTER_RE = /^---\n([\s\S]*?)\n---/m;
+
+function parseFrontmatter(content) {
+  const m = FRONTMATTER_RE.exec(content);
+  if (!m) return null;
+  const out = {};
+  let currentArrayKey = null;
+  for (const rawLine of m[1].split('\n')) {
+    const line = rawLine.replace(/\r$/, '');
+    if (!line.trim()) continue;
+    if (currentArrayKey && /^\s*-\s+/.test(line)) {
+      out[currentArrayKey].push(line.replace(/^\s*-\s+/, '').trim());
+      continue;
+    }
+    currentArrayKey = null;
+    const kv = /^([a-z_]+):\s*(.*)$/.exec(line);
+    if (!kv) continue;
+    const [, key, valueRaw] = kv;
+    const value = valueRaw.trim();
+    if (value === '') {
+      out[key] = [];
+      currentArrayKey = key;
+    } else if (value.startsWith('[') && value.endsWith(']')) {
+      const items = value.slice(1, -1).split(',').map((s) => s.trim()).filter(Boolean);
+      out[key] = items;
+    } else if (value === 'null') {
+      out[key] = null;
+    } else if (/^-?\d+$/.test(value)) {
+      out[key] = Number(value);
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+
+/**
+ * Read and parse every overlay in skills/roles/. Returns { path, frontmatter }
+ * tuples. Files without parseable frontmatter are skipped silently.
+ */
+export function listAllFlavors() {
+  if (!fs.existsSync(FLAVORS_DIR)) return [];
+  const out = [];
+  for (const f of fs.readdirSync(FLAVORS_DIR)) {
+    if (!f.endsWith('.md') || f === 'README.md') continue;
+    const full = path.join(FLAVORS_DIR, f);
+    const content = fs.readFileSync(full, 'utf8');
+    const fm = parseFrontmatter(content);
+    if (fm) out.push({ path: full, file: f, frontmatter: fm });
+  }
+  return out;
+}
+
+/**
+ * Return overlays that match the given role (any-flavor for that role) and
+ * apply to the given profile. Pass undefined for either to skip that filter.
+ */
+export function listFlavors({ role, profile } = {}) {
+  return listAllFlavors().filter(({ frontmatter }) => {
+    if (role) {
+      const roleId = frontmatter.role || '';
+      const baseRole = roleId.split('.')[0];
+      if (baseRole !== role && roleId !== role) return false;
+    }
+    if (profile) {
+      const profiles = frontmatter.profiles;
+      if (!Array.isArray(profiles) || profiles.length === 0) return true;
+      if (!profiles.includes(profile)) return false;
+    }
+    return true;
+  });
+}
+
+/**
+ * Count flavor overlays per base role for a given profile.
+ * Returns { [baseRole]: count }. Excludes the canonical base file (e.g.
+ * architect.md) so only true flavors count toward the cap.
+ */
+export function perRoleFlavorCount(profile = 'rnd') {
+  const counts = {};
+  for (const entry of listFlavors({ profile })) {
+    const roleId = entry.frontmatter.role || '';
+    const isFlavor = roleId.includes('.');
+    if (!isFlavor) continue;
+    const base = roleId.split('.')[0];
+    counts[base] = (counts[base] || 0) + 1;
+  }
+  return counts;
+}
+
+/**
+ * Validate one overlay's frontmatter against the schema invariants. Returns
+ * an array of error strings; empty array means valid.
+ */
+export function validateFlavor(filePath) {
+  const errors = [];
+  if (!fs.existsSync(filePath)) return [`file not found: ${filePath}`];
+  const content = fs.readFileSync(filePath, 'utf8');
+  const fm = parseFrontmatter(content);
+  if (!fm) return [`${filePath}: missing or unparseable frontmatter`];
+
+  if (!fm.role || !/^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)?$/.test(fm.role)) {
+    errors.push(`${filePath}: invalid role "${fm.role}"`);
+  }
+  if (!Array.isArray(fm.applies_to) || fm.applies_to.length === 0) {
+    errors.push(`${filePath}: applies_to must be a non-empty array`);
+  }
+  if (!Array.isArray(fm.profiles) || fm.profiles.length === 0) {
+    errors.push(`${filePath}: profiles must be a non-empty array (run scripts/migrate-flavors.mjs)`);
+  }
+  return errors;
+}

package/lib/hooks/agent-tracker.mjs

@@ -119,7 +119,7 @@ try {
     if (success !== null) {
       const learningDir = join(cxDir, 'learning', agentName);
       mkdirSync(learningDir, { recursive: true });
-      
+
       const learningFile = join(learningDir, `${Date.now()}-${success ? 'success' : 'failure'}.json`);
       const learningEntry = {
         agent: agentName,
@@ -127,13 +127,32 @@ try {
         description,
         outcome,
         timestamp: new Date().toISOString(),
-        // Extract potential patterns from description
         keywords: extractKeywords(description),
         taskType: classifyTaskType(description)
       };
-      
+
       writeFileSync(learningFile, JSON.stringify(learningEntry, null, 2) + '\n');
     }
+
+    // A3 outcome capture: record the per-project outcome JSONL that feeds
+    // .cx/outcomes/_summary.json and the classifier's tiebreaker. Best-effort;
+    // any failure leaves the existing telemetry paths above untouched.
+    if (success !== null) {
+      try {
+        const { recordOutcome } = await import('../outcomes/record.mjs');
+        const { resolveActiveProfile } = await import('../profiles/loader.mjs');
+        const roleId = agentName.replace(/^cx-/, '');
+        const projectCwd = input?.cwd || process.cwd();
+        const activeProfile = resolveActiveProfile(projectCwd);
+        recordOutcome(projectCwd, {
+          role: roleId,
+          success,
+          notes: outcome,
+          source: 'agent-tracker',
+          profile: activeProfile?.id ?? null,
+        });
+      } catch { /* best effort */ }
+    }
   }
   
 } catch (error) {

package/lib/hooks/pre-push-gate.mjs

@@ -189,13 +189,26 @@ function runNpmGate(projectDir) {
   const jobs = [];
   if (hasTest || hasCi) jobs.push({ label: 'tests', cmd: runner, args: ['run', testScript],                  timeout: 90_000 });
   if (hasBuild)         jobs.push({ label: 'build', cmd: runner, args: ['run', 'build'],                     timeout: 120_000 });
-  jobs.push({                       label: 'audit', cmd: 'npm',  args: ['audit', '--omit=dev', '--audit-level=high'], timeout: 30_000 });
+  // Use the project's package manager for audit so the lockfile format matches.
+  const auditArgs = runner === 'pnpm'
+    ? ['audit', '--prod', '--audit-level=high']
+    : runner === 'yarn'
+      ? ['npm-audit', '--groups', 'dependencies', '--level', 'high']
+      : ['audit', '--omit=dev', '--audit-level=high'];
+  jobs.push({                       label: 'audit', cmd: runner, args: auditArgs, timeout: 30_000 });
 
   if (existsSync(join(projectDir, 'bin/construct'))) {
     jobs.push({ label: 'evals', cmd: 'node', args: ['bin/construct', 'evals', 'retrieval'], timeout: 60_000 });
     jobs.push({ label: 'docs',  cmd: 'node', args: ['bin/construct', 'docs:verify'],        timeout: 15_000 });
   }
 
+  if (existsSync(join(projectDir, 'scripts/lint-prose.mjs'))) {
+    jobs.push({ label: 'prose',    cmd: 'node', args: ['scripts/lint-prose.mjs'],         timeout: 15_000 });
+  }
+  if (existsSync(join(projectDir, 'scripts/lint-profiles.mjs'))) {
+    jobs.push({ label: 'profiles', cmd: 'node', args: ['scripts/lint-profiles.mjs', '--quiet'], timeout: 15_000 });
+  }
+
   return { projectDir, jobs };
 }
 

package/lib/hooks/session-optimize.mjs

@@ -128,8 +128,9 @@ function optimizeAgent(agentName) {
   const startTime = Date.now();
   
   try {
-    // Run construct optimize with auto-apply (no --dry-run)
-    const result = spawnSync(CONSTRUCT_BIN, ['optimize', agentName, `--days=${OPTIMIZATION_DAYS}`], {
+    // Preview only. The new contract requires an explicit --apply from the
+    // operator; hook-driven runs must never modify prompt files.
+    const result = spawnSync(CONSTRUCT_BIN, ['optimize', agentName, `--days=${OPTIMIZATION_DAYS}`, '--dry-run'], {
       cwd,
       encoding: 'utf8',
       timeout: 300000, // 5 minutes timeout for optimization

package/lib/hooks/session-reflect.mjs

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+/**
+ * lib/hooks/session-reflect.mjs — Session end auto-reflect hook.
+ *
+ * Runs as a Stop hook. Reads the transcript, extracts a deterministic session
+ * summary, and records it via the observation store so subsequent sessions
+ * can search what happened. Closes the manual-reflect gap that left learning
+ * to operator discipline.
+ *
+ * Hard 500ms wall-clock budget. Exits 0 on any failure — observation capture
+ * is best-effort by design.
+ *
+ * Opt-out: CONSTRUCT_REFLECT_AUTO=off
+ *
+ * @p95ms 300
+ * @maxBlockingScope Stop
+ */
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+const HARD_BUDGET_MS = 500;
+const startedAt = Date.now();
+
+// Opt-out before any heavy work — the env check is cheaper than parsing input.
+if (process.env.CONSTRUCT_REFLECT_AUTO === 'off') process.exit(0);
+
+let input = {};
+try { input = JSON.parse(readFileSync(0, 'utf8')); } catch { process.exit(0); }
+
+const cwd = input?.cwd || process.cwd();
+const projectName = cwd.split('/').pop() || 'project';
+
+// Only run for Construct projects — same gate as session-optimize.mjs.
+if (projectName !== 'construct' && !existsSync(join(cwd, '.cx'))) process.exit(0);
+
+const transcriptPath =
+  input?.transcript_path ||
+  input?.transcriptPath ||
+  process.env.CLAUDE_TRANSCRIPT_PATH ||
+  null;
+
+if (!transcriptPath) process.exit(0);
+
+// Wall-clock budget guard. If the extractor blows past the cap (it shouldn't
+// — it's deterministic and O(n) over transcript lines), the parent process
+// exits without writing. The next session-stop tries again.
+const deadline = setTimeout(() => process.exit(0), HARD_BUDGET_MS);
+deadline.unref();
+
+try {
+  const { runReflectAuto } = await import('../reflect.mjs');
+  const sessionId = input?.session_id || input?.sessionId || null;
+  const durationMs = input?.session_duration_ms || null;
+  await runReflectAuto({ transcriptPath, cwd, sessionId, durationMs });
+} catch {
+  // Best-effort — observation capture must not affect session exit.
+}
+
+const elapsed = Date.now() - startedAt;
+if (elapsed > HARD_BUDGET_MS) {
+  // Log only if budget exceeded — surfaces in construct doctor if it becomes
+  // a pattern. Otherwise silent.
+  try {
+    process.stderr.write(`[session-reflect] over budget: ${elapsed}ms\n`);
+  } catch { /* stderr closed — nothing to do */ }
+}
+
+process.exit(0);

package/lib/init-unified.mjs

@@ -49,6 +49,12 @@ const interactive = args.includes("--interactive") || args.includes("-i");
 const quiet = args.includes("--quiet") || args.includes("-q");
 const skipInteractive = !interactive;
 
+// Active profile selector. `--profile=<id>` writes the field into the
+// project's construct.config.json so resolveActiveProfile 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 created = [];
 const skipped = [];
 
@@ -795,12 +801,29 @@ function initializeBeadsTracker(target) {
 
 async function main() {
   const projectName = inferProjectName(target);
-  
+
   const { clean } = preflight(target);
-  
+
   if (!quiet) {
     console.log(`Initializing Construct in ${path.relative(process.cwd(), target) || "."}`);
   }
+
+  // Persist --profile=<id> into construct.config.json. Validate against the
+  // curated catalog so a typo never silently falls back to rnd.
+  if (profileId) {
+    const { loadProfile, listProfiles } = await import('./profiles/loader.mjs');
+    if (!loadProfile(profileId)) {
+      console.error(`Unknown profile: ${profileId}. Available: ${listProfiles().join(', ')}`);
+      process.exit(1);
+    }
+    const { findProjectConfigPath, loadProjectConfig, writeProjectConfig, PROJECT_CONFIG_FILENAME } = await import('./config/project-config.mjs');
+    const found = findProjectConfigPath(target);
+    const cfgPath = found || path.join(target, PROJECT_CONFIG_FILENAME);
+    const cfg = found ? (loadProjectConfig(target) || { version: 1 }) : { version: 1 };
+    cfg.profile = profileId;
+    writeProjectConfig(cfgPath, cfg, { validate: true });
+    if (!quiet) console.log(`Profile set to ${profileId}.`);
+  }
   
   // Always create core Construct files
   writeStampedIfMissing({

package/lib/intake/classify.mjs

@@ -1,47 +1,26 @@
 /**
- * lib/intake/classify.mjs — R&D triage classification for intake packets.
+ * lib/intake/classify.mjs — Profile-aware triage classification for intake packets.
  *
- * Deterministic, keyword-driven classifier that maps a raw intake signal
- * onto the R&D loop: intakeType (what kind of work), rdStage (where in
- * the loop), primaryOwner persona, recommendedChain (handoff sequence),
- * recommendedAction, risk, requiresApproval, confidence, rationale.
+ * Deterministic, keyword-driven classifier that maps a raw intake signal onto
+ * the active org profile's loop. Returns a triage object with: intakeType,
+ * rdStage, primaryOwner, recommendedChain, recommendedAction, risk,
+ * requiresApproval, confidence, rationale.
  *
  * NO LLM call. The daemon path must remain synchronous and cheap; intent
  * verification belongs in offline measurement, not inline classification.
- * Persona names match agents/registry.json (unprefixed).
+ *
+ * Default profile is `rnd` so existing R&D users see no behavior change.
+ * The `tests/intake/golden-rnd.test.mjs` test locks that invariant.
  */
 
 import path from 'node:path';
 
-export const INTAKE_TYPES = [
-  'user-signal',
-  'bug',
-  'requirement',
-  'research',
-  'experiment',
-  'eval-finding',
-  'architecture',
-  'incident',
-  'launch-asset',
-  'ops',
-  'security',
-  'legal-compliance',
-  'unknown',
-];
-
-export const RD_STAGES = [
-  'signal',
-  'framing',
-  'hypothesis',
-  'research',
-  'artifact',
-  'design',
-  'implementation',
-  'evaluation',
-  'release',
-  'operations',
-  'unknown',
-];
+// Backward-compatible exports. Default to RND values for any module that
+// imports these constants directly (the symbol surface predates B2 and is
+// referenced by intake-config, prepare, and tests).
+import rndTable from './tables/rnd.mjs';
+export const INTAKE_TYPES = rndTable.INTAKE_TYPES;
+export const RD_STAGES = rndTable.STAGES;
 
 export const RECOMMENDED_ACTIONS = [
   'summarize',
@@ -60,146 +39,36 @@ export const RECOMMENDED_ACTIONS = [
   'archive',
 ];
 
-/**
- * Classification table — intakeType → triage spine.
- * Keyword set drives detection; the rest of the row is the canonical mapping
- * for that signal class. Order matters for tie-breaking: earlier rows win on
- * equal raw scores so that high-stakes classes (security, incident) take
- * precedence over generic ones (research) when keywords overlap.
- */
-const CLASSIFICATION_TABLE = [
-  {
-    intakeType: 'security',
-    keywords: ['security', 'secret', 'cve', 'vulnerability', 'vuln', 'exploit', 'leak', 'auth bypass', 'privilege escalation', 'sqli', 'xss', 'csrf', 'rce'],
-    rdStage: 'operations',
-    primaryOwner: 'security',
-    recommendedChain: ['security', 'engineer', 'reviewer'],
-    recommendedAction: 'diagnose',
-    risk: 'high',
-    requiresApproval: true,
-  },
-  {
-    intakeType: 'incident',
-    keywords: ['incident', 'outage', 'slo breach', 'sla breach', 'latency spike', 'availability', 'down', 'p0 ', 'p1 ', 'pagerduty', '5xx', 'oncall'],
-    rdStage: 'operations',
-    primaryOwner: 'sre',
-    recommendedChain: ['sre', 'debugger', 'platform-engineer'],
-    recommendedAction: 'create-runbook',
-    risk: 'high',
-    requiresApproval: true,
-  },
-  {
-    intakeType: 'legal-compliance',
-    keywords: ['gdpr', 'ccpa', 'hipaa', 'sox', 'soc2', 'license', 'lawsuit', 'dpa', 'data retention', 'pii', 'subpoena', 'compliance audit'],
-    rdStage: 'operations',
-    primaryOwner: 'legal-compliance',
-    recommendedChain: ['legal-compliance', 'security', 'product-manager'],
-    recommendedAction: 'clarify',
-    risk: 'high',
-    requiresApproval: true,
-  },
-  {
-    intakeType: 'architecture',
-    keywords: ['architecture', 'adr', 'rfc', 'interface', 'tradeoff', 'boundary', 'system design', 'data model', 'api contract', 'migration plan'],
-    rdStage: 'design',
-    primaryOwner: 'architect',
-    recommendedChain: ['architect', 'devil-advocate', 'engineer'],
-    recommendedAction: 'draft-rfc',
-    risk: 'medium',
-    requiresApproval: false,
-  },
-  {
-    intakeType: 'eval-finding',
-    keywords: ['eval', 'evaluation', 'hallucination', 'judge', 'trace', 'score regression', 'recall@', 'precision@', 'mrr', 'ndcg', 'failure case', 'rubric'],
-    rdStage: 'evaluation',
-    primaryOwner: 'evaluator',
-    recommendedChain: ['evaluator', 'ai-engineer', 'trace-reviewer'],
-    recommendedAction: 'evaluate',
-    risk: 'medium',
-    requiresApproval: false,
-  },
-  {
-    intakeType: 'bug',
-    keywords: ['bug', 'broken', 'error', 'stack trace', 'regression', 'crash', 'exception', 'fails', 'failing', 'throws', 'not working', 'reproduce', 'repro:'],
-    rdStage: 'implementation',
-    primaryOwner: 'debugger',
-    recommendedChain: ['debugger', 'engineer', 'qa', 'reviewer'],
-    recommendedAction: 'diagnose',
-    risk: 'medium',
-    requiresApproval: false,
-  },
-  {
-    intakeType: 'experiment',
-    keywords: ['hypothesis', 'experiment', 'spike', 'prototype', 'falsifiable', 'research question', 'a/b test', 'pilot'],
-    rdStage: 'hypothesis',
-    primaryOwner: 'rd-lead',
-    recommendedChain: ['rd-lead', 'researcher', 'evaluator'],
-    recommendedAction: 'create-experiment',
-    risk: 'low',
-    requiresApproval: false,
-  },
-  {
-    intakeType: 'launch-asset',
-    keywords: ['release', 'changelog', 'version bump', 'ship', 'launch', 'rollout', 'cut a release', 'rc1', 'rc2', 'release candidate'],
-    rdStage: 'release',
-    primaryOwner: 'release-manager',
-    recommendedChain: ['release-manager', 'qa', 'docs-keeper'],
-    recommendedAction: 'release-review',
-    risk: 'medium',
-    requiresApproval: false,
-  },
-  {
-    intakeType: 'research',
-    keywords: ['competitor', 'market', 'pricing', 'positioning', 'industry', 'state of the art', 'literature', 'benchmark study', 'desk research'],
-    rdStage: 'research',
-    primaryOwner: 'business-strategist',
-    recommendedChain: ['business-strategist', 'researcher', 'product-manager'],
-    recommendedAction: 'research',
-    risk: 'low',
-    requiresApproval: false,
-  },
-  {
-    intakeType: 'user-signal',
-    keywords: ['customer', 'feedback', 'pain point', 'user says', 'user feedback', 'support ticket', 'churn', 'nps', 'usability', 'frustrated'],
-    rdStage: 'signal',
-    primaryOwner: 'product-manager',
-    recommendedChain: ['product-manager', 'ux-researcher', 'researcher'],
-    recommendedAction: 'clarify',
-    risk: 'low',
-    requiresApproval: false,
-  },
-  {
-    intakeType: 'requirement',
-    keywords: ['acceptance criteria', 'requirement', 'must have', 'should have', 'feature request', 'prd', 'use case', 'success metric'],
-    rdStage: 'framing',
-    primaryOwner: 'product-manager',
-    recommendedChain: ['product-manager', 'architect', 'engineer'],
-    recommendedAction: 'draft-prd',
-    risk: 'low',
-    requiresApproval: false,
-  },
-  {
-    intakeType: 'ops',
-    keywords: ['runbook', 'cron', 'scheduled job', 'maintenance', 'backup', 'restore', 'capacity plan', 'cost optimization', 'dependency upgrade'],
-    rdStage: 'operations',
-    primaryOwner: 'operations',
-    recommendedChain: ['operations', 'sre', 'engineer'],
-    recommendedAction: 'create-runbook',
-    risk: 'low',
-    requiresApproval: false,
-  },
-];
+// Static profile → table map. New curated profiles register themselves here.
+// Custom profiles (escape hatch) declare classificationTable as a repo-relative
+// path; that path is loaded dynamically in classifyRdIntake when a profile arg
+// supplies it.
+import operationsTable from './tables/operations.mjs';
+import creativeTable from './tables/creative.mjs';
+import researchTable from './tables/research.mjs';
+import { outcomeBoost } from '../outcomes/aggregate.mjs';
+
+// Outcome boost is a soft re-rank applied when a cwd is supplied. Capped at
+// ±0.05 in outcomeBoost itself, so the primary keyword signal (integer hits)
+// always dominates. Returns 0 if no outcome data exists for the role.
+function outcomeBoostFor(cwd, role) {
+  if (!cwd || !role) return 0;
+  try { return outcomeBoost(cwd, role); } catch { return 0; }
+}
 
-const UNKNOWN_TRIAGE = {
-  intakeType: 'unknown',
-  rdStage: 'unknown',
-  primaryOwner: 'orchestrator',
-  recommendedChain: ['orchestrator'],
-  recommendedAction: 'summarize',
-  risk: 'low',
-  requiresApproval: false,
+const TABLES = {
+  rnd: rndTable,
+  operations: operationsTable,
+  creative: creativeTable,
+  research: researchTable,
 };
 
+function resolveTable(profile) {
+  if (!profile) return rndTable;
+  const id = typeof profile === 'string' ? profile : profile.id;
+  return TABLES[id] || rndTable;
+}
+
 function normalize(text) {
   return String(text || '').toLowerCase();
 }
@@ -225,27 +94,35 @@ function buildSignalText({ sourcePath, extractedText, related }) {
 }
 
 /**
- * Classify an R&D intake signal.
+ * Classify an intake signal against the active profile (defaults to RND).
+ *
+ * Backward-compatible: callers that did not pass a `profile` arg keep getting
+ * RND output, byte-identical to the pre-B2 behavior.
  *
- * Returns a triage object with: intakeType, rdStage, primaryOwner,
- * recommendedChain, recommendedAction, risk, requiresApproval, confidence,
- * rationale. The function is pure and deterministic; same input → same output.
+ * @param {object} input
+ * @param {string} [input.sourcePath]
+ * @param {string} [input.extractedText]
+ * @param {Array} [input.related]
+ * @param {string|object} [input.profile] - profile id (string) or full profile object
  */
-export function classifyRdIntake({ sourcePath = '', extractedText = '', related = [] } = {}) {
+export function classifyRdIntake({ sourcePath = '', extractedText = '', related = [], profile = null, cwd = null } = {}) {
+  const table = resolveTable(profile);
   const signal = buildSignalText({ sourcePath, extractedText, related });
 
   let best = null;
-  for (const entry of CLASSIFICATION_TABLE) {
+  for (const entry of table.CLASSIFICATION_TABLE) {
     const { hits, matched } = countMatches(signal, entry.keywords);
     if (hits === 0) continue;
-    if (!best || hits > best.hits) {
-      best = { entry, hits, matched };
+    const boost = cwd ? outcomeBoostFor(cwd, entry.primaryOwner) : 0;
+    const score = hits + boost;
+    if (!best || score > best.score) {
+      best = { entry, hits, matched, score };
     }
   }
 
   if (!best) {
     return {
-      ...UNKNOWN_TRIAGE,
+      ...table.UNKNOWN_TRIAGE,
       confidence: 0.3,
       rationale: 'No classification keywords matched filename, content excerpt, or related-doc titles.',
     };
@@ -272,7 +149,8 @@ export function classifyRdIntake({ sourcePath = '', extractedText = '', related
 export function formatTriageLine(sourcePath, triage) {
   const basename = sourcePath ? path.basename(sourcePath) : '(unknown source)';
   if (!triage || triage.intakeType === 'unknown') {
-    return `${basename} → unclassified · owner: orchestrator · next: summarize`;
+    return `${basename} → unclassified · owner: ${triage?.primaryOwner ?? 'orchestrator'} · next: ${triage?.recommendedAction ?? 'summarize'}`;
   }
-  return `${basename} → ${triage.intakeType} / ${triage.rdStage} · owner: ${triage.primaryOwner} · next: ${triage.recommendedAction}`;
+  const ownerLabel = triage.primaryOwner ?? 'unassigned';
+  return `${basename} → ${triage.intakeType} / ${triage.rdStage} · owner: ${ownerLabel} · next: ${triage.recommendedAction}`;
 }

package/lib/intake/prepare.mjs

@@ -29,6 +29,7 @@ import { suggestDocsLaneForFile } from '../docs-routing.mjs';
 import { createIntakeQueue } from './queue.mjs';
 import { classifyRdIntake } from './classify.mjs';
 import { detectCustomerMentions, linkSignalToCustomer, updateCustomerProfile } from '../embed/customer-profiles.mjs';
+import { resolveActiveProfile } from '../profiles/loader.mjs';
 
 const DEFAULT_RELATED_LIMIT = 5;
 const EXCERPT_CHARS = 800;
@@ -67,10 +68,16 @@ export async function prepareIntakeForIngestedFile({
   }
 
   const lane = suggestDocsLaneForFile(ingestedFile.sourcePath, extracted) || null;
+  // 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({
     sourcePath: ingestedFile.sourcePath,
     extractedText: extracted,
     related,
+    profile: activeProfile?.id,
+    cwd: rootDir,
   });
 
   // Detect customer mentions and update profiles