@geraldmaron/construct 1.2.3 → 1.3.1

package/lib/{profiles → scopes}/lifecycle.mjs

@@ -1,7 +1,7 @@
 /**
- * lib/profiles/lifecycle.mjs — Profile lifecycle operations.
+ * lib/scopes/lifecycle.mjs — Scope lifecycle operations.
  *
- * A profile is a curated description of an org's work loop, intake taxonomy,
+ * A scope is a curated description of an org's work loop, intake taxonomy,
  * role set, and rebrand language. Creating one is a research task, not a
  * code task. The module enforces that by producing a draft + a requirements
  * brief that names which existing Construct specialists are expected to
@@ -9,44 +9,44 @@
  * answers, then promote the draft.
  *
  * Lifecycle stages:
- *   draft     - in `.cx/profiles/draft-<id>/` with requirements.md + profile.json
- *   active    - in `profiles/<id>.json` (curated) or `.cx/profile.json` (custom)
- *   archived  - in `archive/profiles/<id>/` with the final state and an
+ *   draft     - in `.cx/scopes/draft-<id>/` with requirements.md + scope.json
+ *   active    - in `specialists/org/scopes/<id>.json` (curated) or `.cx/scope.json` (custom)
+ *   archived  - in `archive/scopes/<id>/` with the final state and an
  *               archive-note.md explaining why it was retired
  *
- * Health: per-profile observation and outcome counts pulled from the existing
- * stores, so profile health travels alongside the rest of the learning loops.
+ * Health: per-scope observation and outcome counts pulled from the existing
+ * stores, so scope health travels alongside the rest of the learning loops.
  *
- * Lifecycle events: createDraftProfile and archiveProfile each fire a
- * profile.updated role event so subscribers can react to taxonomy changes
+ * Lifecycle events: createDraftScope and archiveScope each fire a
+ * scope.updated role event so subscribers can react to taxonomy changes
  * without polling the filesystem.
  */
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-import { listProfiles, loadProfile } from './loader.mjs';
+import { listScopes, loadScope } from './loader.mjs';
 import { emitBestEffort as emitRoleEvent } from '../roles/event-bus.mjs';
 
 const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 const REPO_ROOT = path.resolve(MODULE_DIR, '..', '..');
 
 function draftDir(cwd, id) {
-  return path.join(cwd, '.cx', 'profiles', `draft-${id}`);
+  return path.join(cwd, '.cx', 'scopes', `draft-${id}`);
 }
 
 function archiveDir(cwd, id) {
-  return path.join(cwd, 'archive', 'profiles', id);
+  return path.join(cwd, 'archive', 'scopes', id);
 }
 
-const REQUIREMENTS_BRIEF = (id, displayName) => `# Profile requirements: ${displayName} (${id})
+const REQUIREMENTS_BRIEF = (id, displayName) => `# Scope requirements: ${displayName} (${id})
 
-This brief is a discovery and design contract for a new Construct profile. Methodology lives in \`docs/guides/concepts/persona-research.md\` and lifecycle in \`docs/guides/concepts/profile-lifecycle.md\`. Treat each section as a task to dispatch to the named specialist. A draft profile is not ready to promote until every section has evidence backing it. The aim is research-grounded, not opinion-grounded.
+This brief is a discovery and design contract for a new Construct scope. Methodology lives in \`docs/guides/concepts/persona-research.md\` and lifecycle in \`docs/guides/concepts/scope-lifecycle.md\`. Treat each section as a task to dispatch to the named specialist. A draft scope is not ready to promote until every section has evidence backing it. The aim is research-grounded, not opinion-grounded.
 
 Specialists used here are the existing Construct cx-* personas (already in the registry). They are dispatched the standard way; this doc just names which questions each one owns.
 
 This draft scaffolding produces:
-- \`profile.json\` — the structural definition (departments, roles, intake)
+- \`scope.json\` — the structural definition (departments, roles, intake)
 - \`requirements.md\` — this brief
 - \`personas/<role>.md\` — one persona artifact per role (filled during the discover phase)
 - \`departments/<dept>.md\` — one charter doc per department (filled during the frame phase)
@@ -77,17 +77,17 @@ Goal: turn discovery into an intake taxonomy and a stage sequence.
 
 Goal: define the role set and how it interlocks with the curated cx-* registry.
 
-- List role ids the profile will reference (max 80, grouped into max 12 departments with max 20 roles per department). For each, indicate one of:
+- List role ids the scope will reference (max 80, grouped into max 12 departments with max 20 roles per department). For each, indicate one of:
   reuse-existing (name the cx-* agent), create-new (specify scope), or compose-overlay (which base role + which flavor).
 - Identify cross-role handoffs. Where can ambiguity stall the loop? Name the orchestrator role.
-- Validate against the per-role cap (max 6 flavors per role per profile).
-- Acceptance: every declared role either exists in specialists/registry.json or has a written scope statement.
+- Validate against the per-role cap (max 6 flavors per role per scope).
+- Acceptance: every declared role either exists in specialists/org or has a written scope statement.
 
 ## 4. Validation (cx-evaluator)
 
 Goal: prove the draft works on real signals before promotion.
 
-- Run \`construct profile classify --draft=${id} --fixture=<path>\` against at least 5 representative signals.
+- Run \`construct scope classify --draft=${id} --fixture=<path>\` against at least 5 representative signals.
 - Score: precision (right intake type), recall (no false unknowns), routing-confidence (median).
 - Acceptance: precision >= 0.7, recall >= 0.7, no \`unknown\` for the canonical signals.
 
@@ -95,29 +95,29 @@ Goal: prove the draft works on real signals before promotion.
 
 Goal: move the draft into the active catalog.
 
-- Curated path: hand-edit \`profiles/${id}.json\` from this draft, open a PR, run \`npm run lint:profiles\`.
-- Custom path: copy the draft profile.json to \`<project>/.cx/profile.json\` with \`"custom": true\`; \`construct profile set\` for switching between curated.
+- Curated path: hand-edit \`specialists/org/scopes/${id}.json\` from this draft, open a PR, run \`npm run lint:scopes\`.
+- Custom path: copy the draft scope.json to \`<project>/.cx/scope.json\` with \`"custom": true\`; \`construct scope set\` for switching between curated.
 - Either path requires the validation acceptance criteria above to be met.
 
 ## 6. Health monitoring (cx-evaluator + cx-trace-reviewer)
 
-Goal: keep the profile honest after it ships.
+Goal: keep the scope honest after it ships.
 
-- \`construct profile health ${id}\` reports observation counts, per-role outcome rates, classification confidence over a window.
+- \`construct scope health ${id}\` reports observation counts, per-role outcome rates, classification confidence over a window.
 - Any role with success-rate < 0.5 across 10+ runs triggers a review: is the role wrong, the prompt wrong, or the routing wrong?
-- Health data is the input for future profile revisions; never edit a profile without a health report first.
+- Health data is the input for future scope revisions; never edit a scope without a health report first.
 
 ## 7. Archive (cx-docs-keeper + operator)
 
-Goal: retire a profile cleanly without losing the learning.
+Goal: retire a scope cleanly without losing the learning.
 
-- \`construct profile archive ${id}\` moves the profile JSON and the intake table reference into \`archive/profiles/${id}/\`, including the final health report as evidence.
-- Observations and outcomes already recorded under this profile stay in place; they are durable.
+- \`construct scope archive ${id}\` moves the scope JSON and the intake table reference into \`archive/scopes/${id}/\`, including the final health report as evidence.
+- Observations and outcomes already recorded under this scope stay in place; they are durable.
 - An archive-note.md explains why it was retired (superseded by, deprecated for, merged into).
 `;
 
 const DRAFT_PROFILE_TEMPLATE = (id, displayName) => ({
-  $schema: '../schemas/profile.schema.json',
+  $schema: '../schemas/scope.schema.json',
   id,
   displayName: displayName || id,
   tagline: 'Draft. Fill in via the requirements brief.',
@@ -200,11 +200,11 @@ function departmentTemplate(id, displayName) {
 }
 
 /**
- * Scaffold a draft profile under .cx/profiles/draft-<id>/. Returns the paths
- * to the requirements brief and the draft profile JSON.
+ * Scaffold a draft scope under .cx/scopes/draft-<id>/. Returns the paths
+ * to the requirements brief and the draft scope JSON.
  */
 /**
- * Scaffold a draft profile + its persona and department research artifacts.
+ * Scaffold a draft scope + its persona and department research artifacts.
  *
  * @param {object} args
  * @param {string} args.cwd
@@ -213,24 +213,24 @@ function departmentTemplate(id, displayName) {
  * @param {string[]} [args.seedRoles] - role ids to scaffold persona files for
  * @param {Array<{id:string,displayName:string}>} [args.seedDepartments] - departments to scaffold charters for
  */
-export function createDraftProfile({ cwd, id, displayName, seedRoles = [], seedDepartments = [] }) {
-  if (!cwd || !id) throw new Error('createDraftProfile: cwd and id are required');
+export function createDraftScope({ cwd, id, displayName, seedRoles = [], seedDepartments = [] }) {
+  if (!cwd || !id) throw new Error('createDraftScope: cwd and id are required');
   if (!/^[a-z][a-z0-9-]{1,30}$/.test(id)) {
-    throw new Error('createDraftProfile: id must match ^[a-z][a-z0-9-]{1,30}$');
+    throw new Error('createDraftScope: id must match ^[a-z][a-z0-9-]{1,30}$');
   }
-  if (listProfiles().includes(id)) {
-    throw new Error(`createDraftProfile: ${id} already exists in the curated catalog`);
+  if (listScopes().includes(id)) {
+    throw new Error(`createDraftScope: ${id} already exists in the curated catalog`);
   }
   const dir = draftDir(cwd, id);
   if (fs.existsSync(dir)) {
-    throw new Error(`createDraftProfile: draft already exists at ${path.relative(cwd, dir)}; archive or delete it before recreating`);
+    throw new Error(`createDraftScope: draft already exists at ${path.relative(cwd, dir)}; archive or delete it before recreating`);
   }
   fs.mkdirSync(dir, { recursive: true });
   fs.mkdirSync(path.join(dir, 'personas'), { recursive: true });
   fs.mkdirSync(path.join(dir, 'departments'), { recursive: true });
 
   const briefPath = path.join(dir, 'requirements.md');
-  const draftPath = path.join(dir, 'profile.json');
+  const draftPath = path.join(dir, 'scope.json');
   fs.writeFileSync(briefPath, REQUIREMENTS_BRIEF(id, displayName || id));
 
   const draft = DRAFT_PROFILE_TEMPLATE(id, displayName);
@@ -261,26 +261,26 @@ export function createDraftProfile({ cwd, id, displayName, seedRoles = [], seedD
     departmentPaths.push(p);
   }
 
-  emitProfileUpdated({ id, stage: 'draft', dir });
+  emitScopeUpdated({ id, stage: 'draft', dir });
   return { dir, briefPath, draftPath, personaPaths, departmentPaths };
 }
 
-// Lifecycle bridge: emits profile.updated whenever the curated catalog gains
+// Lifecycle bridge: emits scope.updated whenever the curated catalog gains
 // or loses an entry, so subscribers (none by default; project overlays can
 // bind) can react to taxonomy changes.
 
-function emitProfileUpdated(context) {
-  emitRoleEvent('profile.updated', {
-    summary: `profile ${context.stage}: ${context.id}`,
+function emitScopeUpdated(context) {
+  emitRoleEvent('scope.updated', {
+    summary: `scope ${context.stage}: ${context.id}`,
     context,
   });
 }
 
 /**
- * List drafts under .cx/profiles/. Returns [{ id, dir, hasProfile, hasBrief }].
+ * List drafts under .cx/scopes/. Returns [{ id, dir, hasScope, hasBrief }].
  */
 export function listDrafts(cwd) {
-  const root = path.join(cwd, '.cx', 'profiles');
+  const root = path.join(cwd, '.cx', 'scopes');
   if (!fs.existsSync(root)) return [];
   const out = [];
   for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
@@ -291,7 +291,7 @@ export function listDrafts(cwd) {
     out.push({
       id,
       dir,
-      hasProfile: fs.existsSync(path.join(dir, 'profile.json')),
+      hasScope: fs.existsSync(path.join(dir, 'scope.json')),
       hasBrief: fs.existsSync(path.join(dir, 'requirements.md')),
     });
   }
@@ -299,27 +299,27 @@ export function listDrafts(cwd) {
 }
 
 /**
- * Archive a curated profile by moving it (and any artifacts it owns in the
- * repo) into archive/profiles/<id>/. Observations and outcomes are not
+ * Archive a curated scope by moving it (and any artifacts it owns in the
+ * repo) into archive/scopes/<id>/. Observations and outcomes are not
  * touched; they remain as historical record. Requires a non-empty `reason`.
  */
-export function archiveProfile({ id, reason }) {
-  if (!id) throw new Error('archiveProfile: id is required');
+export function archiveScope({ id, reason }) {
+  if (!id) throw new Error('archiveScope: id is required');
   if (!reason || reason.trim().length < 8) {
-    throw new Error('archiveProfile: a substantive reason (>= 8 chars) is required');
+    throw new Error('archiveScope: a substantive reason (>= 8 chars) is required');
   }
-  const srcProfile = path.join(REPO_ROOT, 'profiles', `${id}.json`);
-  if (!fs.existsSync(srcProfile)) {
-    throw new Error(`archiveProfile: ${id} not found in profiles/`);
+  const srcScope = path.join(REPO_ROOT, 'specialists', 'org', 'scopes', `${id}.json`);
+  if (!fs.existsSync(srcScope)) {
+    throw new Error(`archiveScope: ${id} not found in specialists/org/scopes/`);
   }
-  const profileJson = JSON.parse(fs.readFileSync(srcProfile, 'utf8'));
-  const tablePath = typeof profileJson?.intake?.classificationTable === 'string'
-    ? path.join(REPO_ROOT, profileJson.intake.classificationTable)
+  const scopeJson = JSON.parse(fs.readFileSync(srcScope, 'utf8'));
+  const tablePath = typeof scopeJson?.intake?.classificationTable === 'string'
+    ? path.join(REPO_ROOT, scopeJson.intake.classificationTable)
     : null;
 
   const dstDir = archiveDir(REPO_ROOT, id);
   fs.mkdirSync(dstDir, { recursive: true });
-  fs.renameSync(srcProfile, path.join(dstDir, `${id}.json`));
+  fs.renameSync(srcScope, path.join(dstDir, `${id}.json`));
   if (tablePath && fs.existsSync(tablePath)) {
     fs.renameSync(tablePath, path.join(dstDir, path.basename(tablePath)));
   }
@@ -334,23 +334,23 @@ export function archiveProfile({ id, reason }) {
     '',
     '## What stayed',
     '',
-    'Observations and outcomes recorded under this profile remain in `.cx/observations/` and `.cx/outcomes/` and continue to be searchable. The intake table and profile JSON were moved into this directory. To restore: move the files back to their original paths and re-run `npm run lint:profiles`.',
+    'Observations and outcomes recorded under this scope remain in `.cx/observations/` and `.cx/outcomes/` and continue to be searchable. The intake table and scope JSON were moved into this directory. To restore: move the files back to their original paths and re-run `npm run lint:scopes`.',
     '',
   ].join('\n'));
-  emitProfileUpdated({ id, stage: 'archived', dir: dstDir, reason: reason.trim() });
+  emitScopeUpdated({ id, stage: 'archived', dir: dstDir, reason: reason.trim() });
   return { archived: dstDir };
 }
 
 /**
- * Per-profile health rollup. Counts observations and outcomes tagged with
- * the profile id, plus the median classification confidence over a window.
+ * Per-scope health rollup. Counts observations and outcomes tagged with
+ * the scope id, plus the median classification confidence over a window.
  *
  * @param {string} cwd - project root
- * @param {string} profileId
+ * @param {string} scopeId
  * @param {object} [opts]
  * @param {number} [opts.windowDays=30]
  */
-export function profileHealth(cwd, profileId, { windowDays = 30 } = {}) {
+export function scopeHealth(cwd, scopeId, { windowDays = 30 } = {}) {
   const cutoff = Date.now() - windowDays * 24 * 60 * 60 * 1000;
   const obsDir = path.join(cwd, '.cx', 'observations');
   let observationCount = 0;
@@ -361,10 +361,10 @@ export function profileHealth(cwd, profileId, { windowDays = 30 } = {}) {
         const idx = JSON.parse(fs.readFileSync(indexPath, 'utf8'));
         for (const entry of idx) {
           if (Date.parse(entry.createdAt) < cutoff) continue;
-          // Observations stamp project, not profile. Fall back to project ==
-          // profile id for the common case where the operator named them the
+          // Observations stamp project, not scope. Fall back to project ==
+          // scope id for the common case where the operator named them the
           // same; otherwise count under "all" so we never silently report 0.
-          observationCount += entry.project === profileId ? 1 : 0;
+          observationCount += entry.project === scopeId ? 1 : 0;
         }
       } catch { /* unreadable index — health stays 0 */ }
     }
@@ -380,7 +380,7 @@ export function profileHealth(cwd, profileId, { windowDays = 30 } = {}) {
       for (const line of lines) {
         let entry;
         try { entry = JSON.parse(line); } catch { continue; }
-        if (entry.profile !== profileId) continue;
+        if (entry.profile !== scopeId) continue;
         if (Date.parse(entry.ts) < cutoff) continue;
         const r = roleHealth[role] || (roleHealth[role] = { count: 0, success: 0 });
         r.count += 1;
@@ -396,8 +396,8 @@ export function profileHealth(cwd, profileId, { windowDays = 30 } = {}) {
   );
 
   return {
-    profile: profileId,
-    profileExists: !!loadProfile(profileId),
+    scope: scopeId,
+    scopeExists: !!loadScope(scopeId),
     windowDays,
     observationCount,
     roles: roleSummary,

package/lib/scopes/loader.mjs

@@ -0,0 +1,104 @@
+/**
+ * lib/scopes/loader.mjs — Work-scope loader (intake lens + org enrichment).
+ *
+ * Curated scopes live in specialists/org/scopes/<id>.json. Custom overrides
+ * use <cwd>/.cx/scope.json with custom: true. construct.config.json scope
+ * field selects the active scope id (default rnd).
+ *
+ * Teams and roles are not authored in scope files — enrich.mjs attaches them
+ * from specialists/org at load time.
+ */
+
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { enrichScope } from './enrich.mjs';
+
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(MODULE_DIR, '..', '..');
+const SCOPES_DIR = join(REPO_ROOT, 'specialists', 'org', 'scopes');
+
+export const DEFAULT_SCOPE_ID = 'rnd';
+
+export function loadScope(id, opts = {}) {
+  if (!id || typeof id !== 'string') return null;
+  const path = join(SCOPES_DIR, `${id}.json`);
+  if (!existsSync(path)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(path, 'utf8'));
+    return enrichScope(raw, opts);
+  } catch {
+    return null;
+  }
+}
+
+export function listScopes() {
+  if (!existsSync(SCOPES_DIR)) return [];
+  return readdirSync(SCOPES_DIR)
+    .filter((f) => f.endsWith('.json'))
+    .map((f) => f.replace(/\.json$/, ''))
+    .filter((id) => {
+      try {
+        const raw = JSON.parse(readFileSync(join(SCOPES_DIR, `${id}.json`), 'utf8'));
+        return raw?.id === id && raw?.intake?.types && raw?.intake?.stages;
+      } catch {
+        return false;
+      }
+    })
+    .sort();
+}
+
+export function loadCustomScope(cwd) {
+  if (!cwd) return null;
+  const path = join(cwd, '.cx', 'scope.json');
+  if (!existsSync(path)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(path, 'utf8'));
+    if (raw && raw.custom === true) return raw;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export function resolveActiveScope(cwd, configScopeId = null) {
+  const rootDir = REPO_ROOT;
+  const enrichOpts = { rootDir };
+  if (configScopeId) {
+    const s = loadScope(configScopeId, enrichOpts);
+    if (s) return s;
+  }
+  const custom = loadCustomScope(cwd);
+  if (custom) return enrichScope(custom, enrichOpts);
+  const fromConfig = readScopeFromProjectConfig(cwd);
+  if (fromConfig) {
+    const s = loadScope(fromConfig, enrichOpts);
+    if (s) return s;
+  }
+  return loadScope(DEFAULT_SCOPE_ID, enrichOpts) ?? minimalRndFallback();
+}
+
+function readScopeFromProjectConfig(cwd) {
+  if (!cwd) return null;
+  const p = join(cwd, 'construct.config.json');
+  if (!existsSync(p)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(p, 'utf8'));
+    return typeof raw?.scope === 'string' ? raw.scope : null;
+  } catch {
+    return null;
+  }
+}
+
+function minimalRndFallback() {
+  return {
+    id: 'rnd',
+    displayName: 'Software R&D',
+    roles: [],
+    intake: { types: [], stages: [] },
+    docTemplates: [],
+    hooks: { sessionReflect: 'on', sessionOptimize: 'on' },
+    rebrand: { intakeQueueLabel: 'R&D intake queue', signalNoun: 'signal' },
+  };
+}

package/lib/scopes/rebrand.mjs

@@ -0,0 +1,32 @@
+/**
+ * lib/scopes/rebrand.mjs — Scope-aware language helper.
+ *
+ * Each curated scope carries a `rebrand` block: how the active scope
+ * wants the intake queue and individual signal items named in user-facing
+ * surfaces (CLI output, daemon logs, session-start prelude).
+ */
+
+import { resolveActiveScope } from './loader.mjs';
+
+export const DEFAULT_REBRAND = Object.freeze({
+  intakeQueueLabel: 'Intake queue',
+  signalNoun: 'signal',
+});
+
+export function getRebrand(rootDir) {
+  if (!rootDir || typeof rootDir !== 'string') return { ...DEFAULT_REBRAND };
+  try {
+    const scope = resolveActiveScope(rootDir);
+    const rb = scope?.rebrand;
+    if (!rb || typeof rb !== 'object') return { ...DEFAULT_REBRAND };
+    const intakeQueueLabel = typeof rb.intakeQueueLabel === 'string' && rb.intakeQueueLabel.trim()
+      ? rb.intakeQueueLabel.trim()
+      : DEFAULT_REBRAND.intakeQueueLabel;
+    const signalNoun = typeof rb.signalNoun === 'string' && rb.signalNoun.trim()
+      ? rb.signalNoun.trim()
+      : DEFAULT_REBRAND.signalNoun;
+    return { intakeQueueLabel, signalNoun };
+  } catch {
+    return { ...DEFAULT_REBRAND };
+  }
+}

package/lib/scopes/research-profile.mjs

@@ -0,0 +1,16 @@
+/**
+ * lib/scopes/research-profile.mjs — Map intake types to research depth profiles.
+ *
+ * Scope JSON may declare researchProfiles (user, codebase, external, market).
+ * Artifact manifest entries carry a default researchProfile; scope overrides win.
+ */
+
+export function resolveResearchProfile({ intakeType, artifactType, scope } = {}) {
+  if (scope?.researchProfiles && intakeType && scope.researchProfiles[intakeType]) {
+    return scope.researchProfiles[intakeType];
+  }
+  if (scope?.researchProfiles && artifactType && scope.researchProfiles[artifactType]) {
+    return scope.researchProfiles[artifactType];
+  }
+  return null;
+}

package/lib/scopes/teams.mjs

@@ -0,0 +1,98 @@
+/**
+ * lib/scopes/teams.mjs — Scope-aware routing hints over the single org chart.
+ *
+ * Scopes change intake taxonomy and terminology, not org membership. Operations-
+ * scope projects map objectives to existing rnd squads (operations-team,
+ * engineering-team, product-management-team).
+ */
+
+const OPERATIONS_OBJECTIVE_RULES = [
+  {
+    teamId: 'operations-team',
+    focus: 'reliability',
+    attachTo: ['cx-sre', 'cx-docs-keeper'],
+    pattern: /\b(incident|outage|deploy|deployment|rollback|reliability|runbook|postmortem|sre|on-?call)\b/i,
+  },
+  {
+    teamId: 'product-management-team',
+    focus: 'triage',
+    attachTo: ['cx-operations', 'cx-product-manager'],
+    pattern: /\b(triage|route|routing|priority|queue|intake|request|escalat)/i,
+  },
+  {
+    teamId: 'engineering-team',
+    focus: 'implementation',
+    attachTo: ['cx-engineer', 'cx-qa'],
+    pattern: /\b(implement|build|fix|code|test|review|deliver|patch)\b/i,
+  },
+];
+
+export const SCOPE_INTENT_TO_TEAM = Object.freeze({
+  operations: Object.freeze({
+    research: 'product-management-team',
+    implementation: 'engineering-team',
+    investigation: 'operations-team',
+    evaluation: 'engineering-team',
+    fix: 'engineering-team',
+  }),
+});
+
+export function scopeTeamsById(scope) {
+  if (!Array.isArray(scope?.teams) || scope.teams.length === 0) return null;
+  const byId = {};
+  for (const team of scope.teams) {
+    if (team?.id) byId[team.id] = team;
+  }
+  return byId;
+}
+
+export function resolveIntentTeamForScope(intent, scope) {
+  if (!intent || !scope?.id) return null;
+  const map = SCOPE_INTENT_TO_TEAM[scope.id];
+  return map?.[intent] ?? null;
+}
+
+export function classifyObjectiveForScope(objective = '', scope) {
+  const teams = scopeTeamsById(scope);
+  if (!teams) return null;
+
+  if (scope.id === 'operations') {
+    const text = String(objective);
+    for (const rule of OPERATIONS_OBJECTIVE_RULES) {
+      if (rule.pattern.test(text)) {
+        return {
+          focus: rule.focus,
+          attachTo: rule.attachTo,
+          teamFocus: rule.teamId,
+          recommendedTeam: rule.teamId,
+          scopeTeamSource: scope.id,
+        };
+      }
+    }
+    return {
+      focus: 'triage',
+      attachTo: ['cx-operations', 'cx-product-manager'],
+      teamFocus: 'product-management-team',
+      recommendedTeam: 'product-management-team',
+      scopeTeamSource: scope.id,
+    };
+  }
+
+  const firstTeam = scope.teams[0];
+  if (!firstTeam?.id) return null;
+  const attachTo = Array.isArray(firstTeam.specialists) && firstTeam.specialists.length > 0
+    ? firstTeam.specialists
+    : (firstTeam.roles ?? []).map((role) => (role.startsWith('cx-') ? role : `cx-${role}`));
+  return {
+    focus: firstTeam.id,
+    attachTo,
+    teamFocus: firstTeam.id,
+    recommendedTeam: firstTeam.id,
+    scopeTeamSource: scope.id,
+  };
+}
+
+export function resolveScopeTeamMeta(teamId, scope) {
+  const teams = scopeTeamsById(scope);
+  return teams?.[teamId] ?? null;
+}