@geraldmaron/construct 1.2.3 → 1.3.1

package/lib/host-capabilities.mjs

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

package/lib/improvement/controller.mjs

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

package/lib/init-unified.mjs

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

package/lib/intake/classify.mjs

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

package/lib/intake/daemon.mjs

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

package/lib/intake/prepare.mjs

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

package/lib/intake/session-prelude.mjs

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

package/lib/intake/tables/creative.mjs

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

package/lib/intake/tables/operations.mjs

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

package/lib/intake/tables/research.mjs

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

package/lib/integrations/intake-integrations.mjs

@@ -19,6 +19,7 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { spawnSync } from 'node:child_process';
 import { configDir } from '../config/xdg.mjs';
+import { resolveOpRef } from '../providers/secret-resolver.mjs';
 
 // ── Multi-method auth helpers ────────────────────────────────────────────
 
@@ -628,8 +629,7 @@ function resolveCredentialSync(varName, homeDir) {
       const opMatch = content.match(opRe);
       if (opMatch) {
         try {
-          const result = spawnSync('op', ['read', opMatch[1]], { encoding: 'utf8', timeout: 5000 });
-          if (result.status === 0) return result.stdout.trim();
+          return resolveOpRef(opMatch[1]);
         } catch { /* op read failed */ }
       }
     }
@@ -730,16 +730,15 @@ function resolveCredential(varName, homeDir) {
         const opRe = new RegExp(`export\\s+${varName}=["']?\\$\\(op read '([^']+)'\\)["']?`, 'm');
         const opMatch = content.match(opRe);
         if (opMatch) {
+          // op read failures often mean the rc-file field name doesn't match the
+          // actual 1Password item field; surface them under the debug flag.
           try {
-            const result = spawnSync('op', ['read', opMatch[1]], { encoding: 'utf8', timeout: 5000 });
-            if (result.status === 0) return result.stdout.trim();
-            // Log op read failures — often the field name in the rc file
-            // doesn't match the actual 1Password item field name.
-            const errMsg = (result.stderr || '').trim().slice(0, 200);
-            if (errMsg && process.env.CONSTRUCT_DEBUG_CREDENTIALS === '1') {
-              process.stderr.write(`[credentials] op read failed for ${varName}: ${errMsg}\n`);
+            return resolveOpRef(opMatch[1]);
+          } catch (err) {
+            if (process.env.CONSTRUCT_DEBUG_CREDENTIALS === '1') {
+              process.stderr.write(`[credentials] op read failed for ${varName}: ${String(err.message).slice(0, 200)}\n`);
             }
-          } catch { /* op read failed */ }
+          }
         }
 
         // If the value uses command substitution ($(...)), try evaluating via

package/lib/knowledge/research-store.mjs

@@ -18,7 +18,7 @@
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { syncFileStateToSql } from '../storage/sync.mjs';
-import { resolveActiveProfile } from '../profiles/loader.mjs';
+import { resolveActiveScope } from '../scopes/loader.mjs';
 import { ensureCxDir } from '../project-init-shared.mjs';
 
 const ROOT = '.cx/knowledge/external/research';
@@ -64,7 +64,7 @@ export async function addResearchFinding({
     throw new Error('addResearchFinding: confidence=confirmed requires at least one source');
   }
 
-  const profile = resolveActiveProfile(cwd);
+  const profile = resolveActiveScope(cwd);
   const now = new Date();
   const expiresAt = new Date(now.getTime() + ttlDays * 24 * 60 * 60 * 1000).toISOString();