@geraldmaron/construct 1.0.4 → 1.0.6

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

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 };