@geraldmaron/construct 1.0.3 → 1.0.5

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

package/lib/intake/tables/creative.mjs

@@ -0,0 +1,94 @@
+/**
+ * lib/intake/tables/creative.mjs — Creative production intake classification.
+ *
+ * Loop: brief → research → draft → review → publish → measure. Covers content
+ * creation, campaigns, design work. Roles are creative-org roles, not engineering.
+ */
+
+export const INTAKE_TYPES = ['brief', 'content-request', 'asset', 'experiment', 'report', 'legal-compliance', 'ops', 'unknown'];
+export const STAGES = ['brief', 'research', 'draft', 'review', 'publish', 'measure'];
+
+export const UNKNOWN_TRIAGE = {
+  intakeType: 'unknown',
+  rdStage: 'unknown',
+  primaryOwner: 'operator',
+  recommendedChain: ['operator'],
+  recommendedAction: 'summarize',
+  risk: 'low',
+  requiresApproval: false,
+};
+
+export const CLASSIFICATION_TABLE = [
+  {
+    intakeType: 'legal-compliance',
+    keywords: ['gdpr', 'ccpa', 'privacy', 'consent', 'unsubscribe', 'can-spam', 'cookie banner', 'disclosure', 'trademark'],
+    rdStage: 'review',
+    primaryOwner: 'legal-compliance',
+    recommendedChain: ['legal-compliance', 'reviewer'],
+    recommendedAction: 'clarify',
+    risk: 'high',
+    requiresApproval: true,
+  },
+  {
+    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'],
+    recommendedAction: 'draft-prd',
+    risk: 'medium',
+    requiresApproval: false,
+  },
+  {
+    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'],
+    recommendedAction: 'draft-rfc',
+    risk: 'low',
+    requiresApproval: false,
+  },
+  {
+    intakeType: 'asset',
+    keywords: ['asset', 'logo', 'image', 'banner', 'mockup', 'figma', 'brand guide', 'illustration'],
+    rdStage: 'draft',
+    primaryOwner: 'designer',
+    recommendedChain: ['designer', 'reviewer'],
+    recommendedAction: 'draft-rfc',
+    risk: 'low',
+    requiresApproval: false,
+  },
+  {
+    intakeType: 'experiment',
+    keywords: ['a/b test', 'experiment', 'hypothesis', 'multivariate', 'pilot', 'audience test'],
+    rdStage: 'measure',
+    primaryOwner: 'data-analyst',
+    recommendedChain: ['data-analyst', 'researcher'],
+    recommendedAction: 'create-experiment',
+    risk: 'low',
+    requiresApproval: false,
+  },
+  {
+    intakeType: 'report',
+    keywords: ['report', 'dashboard', 'attribution', 'ctr', 'cpa', 'roas', 'conversion', 'funnel', 'engagement'],
+    rdStage: 'measure',
+    primaryOwner: 'data-analyst',
+    recommendedChain: ['data-analyst', 'product-lead'],
+    recommendedAction: 'evaluate',
+    risk: 'low',
+    requiresApproval: false,
+  },
+  {
+    intakeType: 'ops',
+    keywords: ['process', 'workflow', 'template', 'sla', 'calendar', 'planning', 'editorial calendar'],
+    rdStage: 'review',
+    primaryOwner: 'operator',
+    recommendedChain: ['operator', 'product-lead'],
+    recommendedAction: 'create-runbook',
+    risk: 'low',
+    requiresApproval: false,
+  },
+];
+
+export default { INTAKE_TYPES, STAGES, CLASSIFICATION_TABLE, UNKNOWN_TRIAGE };

package/lib/intake/tables/operations.mjs

@@ -0,0 +1,85 @@
+/**
+ * lib/intake/tables/operations.mjs — Operations intake classification.
+ *
+ * Loop: request → triage → resolve → document → improve. Optimized for teams
+ * whose primary work is fulfilling requests and keeping things running, not
+ * building new product. Owners are operations roles (operator, sre, engineer).
+ */
+
+export const INTAKE_TYPES = ['request', 'bug', 'incident', 'ops', 'security', 'docs', 'unknown'];
+export const STAGES = ['request', 'triage', 'resolve', 'document', 'improve'];
+
+export const UNKNOWN_TRIAGE = {
+  intakeType: 'unknown',
+  rdStage: 'unknown',
+  primaryOwner: 'operator',
+  recommendedChain: ['operator'],
+  recommendedAction: 'summarize',
+  risk: 'low',
+  requiresApproval: false,
+};
+
+export const CLASSIFICATION_TABLE = [
+  {
+    intakeType: 'security',
+    keywords: ['security', 'cve', 'vulnerability', 'leak', 'auth bypass', 'pii', 'secret'],
+    rdStage: 'resolve',
+    primaryOwner: 'security',
+    recommendedChain: ['security', 'engineer', 'reviewer'],
+    recommendedAction: 'diagnose',
+    risk: 'high',
+    requiresApproval: true,
+  },
+  {
+    intakeType: 'incident',
+    keywords: ['incident', 'outage', 'down', 'p0 ', 'p1 ', 'oncall', 'pager', '5xx', 'sla breach'],
+    rdStage: 'resolve',
+    primaryOwner: 'sre',
+    recommendedChain: ['sre', 'engineer'],
+    recommendedAction: 'create-runbook',
+    risk: 'high',
+    requiresApproval: true,
+  },
+  {
+    intakeType: 'bug',
+    keywords: ['bug', 'broken', 'error', 'fails', 'crash', 'exception', 'stack trace'],
+    rdStage: 'resolve',
+    primaryOwner: 'engineer',
+    recommendedChain: ['engineer', 'qa', 'reviewer'],
+    recommendedAction: 'diagnose',
+    risk: 'medium',
+    requiresApproval: false,
+  },
+  {
+    intakeType: 'docs',
+    keywords: ['docs', 'documentation', 'how to', 'guide', 'readme', 'wiki', 'runbook missing'],
+    rdStage: 'document',
+    primaryOwner: 'docs-keeper',
+    recommendedChain: ['docs-keeper', 'reviewer'],
+    recommendedAction: 'create-runbook',
+    risk: 'low',
+    requiresApproval: false,
+  },
+  {
+    intakeType: 'ops',
+    keywords: ['cron', 'scheduled job', 'maintenance', 'backup', 'restore', 'rotation', 'capacity', 'upgrade'],
+    rdStage: 'improve',
+    primaryOwner: 'sre',
+    recommendedChain: ['sre', 'engineer'],
+    recommendedAction: 'create-runbook',
+    risk: 'low',
+    requiresApproval: false,
+  },
+  {
+    intakeType: 'request',
+    keywords: ['request', 'access', 'feature request', 'integration', 'new tool', 'change request', 'how do i', 'can someone'],
+    rdStage: 'triage',
+    primaryOwner: 'operator',
+    recommendedChain: ['operator', 'engineer'],
+    recommendedAction: 'clarify',
+    risk: 'low',
+    requiresApproval: false,
+  },
+];
+
+export default { INTAKE_TYPES, STAGES, CLASSIFICATION_TABLE, UNKNOWN_TRIAGE };

package/lib/intake/tables/research.mjs

@@ -0,0 +1,85 @@
+/**
+ * lib/intake/tables/research.mjs — Research intake classification.
+ *
+ * Loop: question → gather → analyze → synthesize → recommend. Covers analysis,
+ * market intelligence, evaluation, advisory work. Output is a written
+ * recommendation, not a shipped product.
+ */
+
+export const INTAKE_TYPES = ['question', 'study', 'synthesis', 'report', 'experiment', 'ops', 'unknown'];
+export const STAGES = ['question', 'gather', 'analyze', 'synthesize', 'recommend'];
+
+export const UNKNOWN_TRIAGE = {
+  intakeType: 'unknown',
+  rdStage: 'unknown',
+  primaryOwner: 'researcher',
+  recommendedChain: ['researcher'],
+  recommendedAction: 'summarize',
+  risk: 'low',
+  requiresApproval: false,
+};
+
+export const CLASSIFICATION_TABLE = [
+  {
+    intakeType: 'study',
+    keywords: ['interview', 'user study', 'survey', 'focus group', 'usability test', 'diary study', 'ethnography'],
+    rdStage: 'gather',
+    primaryOwner: 'ux-researcher',
+    recommendedChain: ['ux-researcher', 'researcher'],
+    recommendedAction: 'create-experiment',
+    risk: 'low',
+    requiresApproval: false,
+  },
+  {
+    intakeType: 'experiment',
+    keywords: ['hypothesis', 'experiment', 'controlled trial', 'a/b test', 'pilot', 'falsifiable'],
+    rdStage: 'analyze',
+    primaryOwner: 'evaluator',
+    recommendedChain: ['evaluator', 'researcher', 'data-analyst'],
+    recommendedAction: 'evaluate',
+    risk: 'low',
+    requiresApproval: false,
+  },
+  {
+    intakeType: 'report',
+    keywords: ['report', 'finding', 'dashboard', 'metric', 'benchmark', 'baseline', 'comparison'],
+    rdStage: 'recommend',
+    primaryOwner: 'data-analyst',
+    recommendedChain: ['data-analyst', 'researcher', 'reviewer'],
+    recommendedAction: 'evaluate',
+    risk: 'low',
+    requiresApproval: false,
+  },
+  {
+    intakeType: 'synthesis',
+    keywords: ['synthesis', 'literature review', 'meta', 'state of the art', 'roundup', 'survey paper', 'taxonomy'],
+    rdStage: 'synthesize',
+    primaryOwner: 'researcher',
+    recommendedChain: ['researcher', 'reviewer'],
+    recommendedAction: 'research',
+    risk: 'low',
+    requiresApproval: false,
+  },
+  {
+    intakeType: 'question',
+    keywords: ['question', 'research question', 'what is', 'why does', 'how do', 'investigate', 'figure out', 'understand'],
+    rdStage: 'question',
+    primaryOwner: 'researcher',
+    recommendedChain: ['researcher'],
+    recommendedAction: 'clarify',
+    risk: 'low',
+    requiresApproval: false,
+  },
+  {
+    intakeType: 'ops',
+    keywords: ['process', 'methodology', 'template', 'protocol', 'consent form', 'data handling'],
+    rdStage: 'gather',
+    primaryOwner: 'operator',
+    recommendedChain: ['operator', 'researcher'],
+    recommendedAction: 'create-runbook',
+    risk: 'low',
+    requiresApproval: false,
+  },
+];
+
+export default { INTAKE_TYPES, STAGES, CLASSIFICATION_TABLE, UNKNOWN_TRIAGE };