@geraldmaron/construct 1.0.4 → 1.0.5

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

package/lib/intake/tables/rnd.mjs

@@ -0,0 +1,175 @@
+/**
+ * lib/intake/tables/rnd.mjs — RND intake classification table.
+ *
+ * Extracted from lib/intake/classify.mjs as part of B2. Behavior must remain
+ * byte-identical for RND inputs; tests/intake/golden-rnd.test.mjs is the
+ * regression guard.
+ *
+ * Schema: { INTAKE_TYPES, STAGES, CLASSIFICATION_TABLE, UNKNOWN_TRIAGE }.
+ * UNKNOWN_TRIAGE handles the no-match fallback for this profile.
+ */
+
+export const INTAKE_TYPES = [
+  'user-signal',
+  'bug',
+  'requirement',
+  'research',
+  'experiment',
+  'eval-finding',
+  'architecture',
+  'incident',
+  'launch-asset',
+  'ops',
+  'security',
+  'legal-compliance',
+  'unknown',
+];
+
+export const STAGES = [
+  'signal',
+  'framing',
+  'hypothesis',
+  'research',
+  'artifact',
+  'design',
+  'implementation',
+  'evaluation',
+  'release',
+  'operations',
+  'unknown',
+];
+
+export const UNKNOWN_TRIAGE = {
+  intakeType: 'unknown',
+  rdStage: 'unknown',
+  primaryOwner: 'orchestrator',
+  recommendedChain: ['orchestrator'],
+  recommendedAction: 'summarize',
+  risk: 'low',
+  requiresApproval: false,
+};
+
+export 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,
+  },
+];
+
+export default { INTAKE_TYPES, STAGES, CLASSIFICATION_TABLE, UNKNOWN_TRIAGE };

package/lib/knowledge/research-store.mjs

@@ -0,0 +1,109 @@
+/**
+ * lib/knowledge/research-store.mjs — Persist research findings into the knowledge base.
+ *
+ * Wraps the existing document-ingest pipeline so research output written via
+ * `construct knowledge add --source=research` lands in
+ * `.cx/knowledge/external/research/<slug>.md` with research-specific frontmatter
+ * (topic, confidence, sources, expiresAt, profile). The file is then synced into
+ * the SQL/vector index via the standard `syncFileStateToSql` path.
+ *
+ * Schema (frontmatter):
+ *   kind: research-finding
+ *   topic: string
+ *   confidence: confirmed | inferred | weak
+ *   sources: [{ url, accessedAt, span? }]
+ *   expiresAt: ISO date (default +90d)
+ *   profile: <profile-id>
+ */
+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';
+
+const ROOT = '.cx/knowledge/external/research';
+const MAX_BYTES = 50 * 1024;
+const DEFAULT_TTL_DAYS = 90;
+
+const VALID_CONFIDENCE = new Set(['confirmed', 'inferred', 'weak']);
+
+/**
+ * @param {object} args
+ * @param {string} args.cwd - project root
+ * @param {string} args.slug - filename slug (lowercase, hyphenated)
+ * @param {string} args.topic - human-readable topic line
+ * @param {string} args.body - the FINDINGS / INFERENCES / GAPS / RECOMMENDATION block
+ * @param {string} [args.confidence] - confirmed | inferred | weak
+ * @param {Array<{url:string,accessedAt?:string,span?:string}>} [args.sources]
+ * @param {number} [args.ttlDays] - override default expiry
+ * @returns {Promise<{path:string,bytes:number}>}
+ */
+export async function addResearchFinding({
+  cwd,
+  slug,
+  topic,
+  body,
+  confidence = 'inferred',
+  sources = [],
+  ttlDays = DEFAULT_TTL_DAYS,
+}) {
+  if (!cwd) throw new Error('addResearchFinding: cwd is required');
+  if (!slug || !/^[a-z0-9][a-z0-9-]{0,60}$/.test(slug)) {
+    throw new Error('addResearchFinding: slug must be lowercase, hyphenated, max 60 chars');
+  }
+  if (!topic || typeof topic !== 'string') {
+    throw new Error('addResearchFinding: topic is required');
+  }
+  if (!body || typeof body !== 'string') {
+    throw new Error('addResearchFinding: body is required');
+  }
+  if (!VALID_CONFIDENCE.has(confidence)) {
+    throw new Error(`addResearchFinding: confidence must be one of ${Array.from(VALID_CONFIDENCE).join(', ')}`);
+  }
+  if (confidence === 'confirmed' && (!Array.isArray(sources) || sources.length === 0)) {
+    throw new Error('addResearchFinding: confidence=confirmed requires at least one source');
+  }
+
+  const profile = resolveActiveProfile(cwd);
+  const now = new Date();
+  const expiresAt = new Date(now.getTime() + ttlDays * 24 * 60 * 60 * 1000).toISOString();
+
+  const outDir = join(cwd, ROOT);
+  mkdirSync(outDir, { recursive: true });
+  const outPath = join(outDir, `${slug}.md`);
+
+  const fmSources = (Array.isArray(sources) ? sources : [])
+    .filter((s) => s && typeof s.url === 'string')
+    .map((s) => ({
+      url: s.url,
+      accessedAt: s.accessedAt || now.toISOString(),
+      ...(s.span ? { span: String(s.span).slice(0, 200) } : {}),
+    }));
+
+  const frontmatter = [
+    '---',
+    'kind: research-finding',
+    `topic: ${JSON.stringify(topic)}`,
+    `confidence: ${confidence}`,
+    `sources: ${JSON.stringify(fmSources)}`,
+    `created: ${now.toISOString()}`,
+    `expiresAt: ${expiresAt}`,
+    `profile: ${profile?.id ?? 'rnd'}`,
+    '---',
+    '',
+  ].join('\n');
+
+  const fullText = frontmatter + body.trim() + '\n';
+  if (Buffer.byteLength(fullText, 'utf8') > MAX_BYTES) {
+    throw new Error(`addResearchFinding: file exceeds ${MAX_BYTES} bytes`);
+  }
+
+  writeFileSync(outPath, fullText);
+
+  // Best-effort sync into SQL/vector index. The file is the source of truth;
+  // index lag never blocks the operator.
+  try {
+    await syncFileStateToSql(cwd, { project: profile?.id ?? 'rnd' });
+  } catch { /* best effort */ }
+
+  return { path: outPath, bytes: Buffer.byteLength(fullText, 'utf8') };
+}

package/lib/observation-store.mjs

@@ -58,6 +58,20 @@ function generateId() {
   return `obs-${ts}-${rand}`;
 }
 
+const MAX_EXTRAS_BYTES = 2 * 1024;
+
+function sanitizeExtras(extras) {
+  if (extras == null) return null;
+  if (typeof extras !== 'object' || Array.isArray(extras)) return null;
+  try {
+    const serialized = JSON.stringify(extras);
+    if (Buffer.byteLength(serialized, 'utf8') > MAX_EXTRAS_BYTES) return null;
+    return JSON.parse(serialized);
+  } catch {
+    return null;
+  }
+}
+
 function clamp(str, max) {
   if (!str || str.length <= max) return str || null;
   return str.slice(0, max - 1) + '\u2026';
@@ -131,6 +145,7 @@ export async function addObservation(rootDir, {
   confidence = 0.8,
   source = null,
   gitSha = null,
+  extras = null,
 } = {}) {
   const id = generateId();
   const now = new Date().toISOString();
@@ -139,6 +154,9 @@ export async function addObservation(rootDir, {
   const clampedSummary = clamp(String(summary), MAX_SUMMARY);
   const clampedContent = clamp(String(content), MAX_CONTENT);
   const clampedTags = (Array.isArray(tags) ? tags : []).slice(0, MAX_TAGS).map(String);
+  // Structured metadata: opt-in. Capped at 2 KB stringified so a misuse can't
+  // bloat the per-id JSON. Plain object only; rejects arrays and functions.
+  const clampedExtras = sanitizeExtras(extras);
 
   const record = {
     id,
@@ -151,6 +169,7 @@ export async function addObservation(rootDir, {
     confidence: Math.max(0, Math.min(1, Number(confidence) || 0.8)),
     source: source || null,
     gitSha: gitSha ? String(gitSha).slice(0, 40) : null,
+    extras: clampedExtras,
     createdAt: now,
     updatedAt: now,
   };