@bongos/core 1.17.0

package/modules/onboarding/onboarding.js

@@ -0,0 +1,508 @@
+// GDS onboarding friction analysis — pure domain logic (V3.R79 / #298).
+//
+// Criterion C1: "feedback without asking." Instead of asking a new builder
+// "what was confusing?", we read their actual onboarding session transcripts
+// and let an Opus subagent surface the friction. Each flagged session becomes
+// one idea_inbox row so a trusted builder can act on it during triage.
+//
+// This module is the *pure* half of the pipeline: parse a Claude Code
+// transcript, compute deterministic friction signals, build the subagent
+// prompt, validate the subagent's JSON, and shape the idea_inbox payload.
+// No filesystem, no network, no DB — that lives in scripts/gds/onboarding-*.js
+// so this stays unit-testable and side-effect free (mirrors how grader.js
+// keeps buildPrompt/validateAndScore pure while runSubagent does the I/O).
+//
+// ## Why a title prefix instead of kind='onboarding-friction'
+//
+// The done-when asks for idea_inbox rows tagged kind='onboarding-friction'.
+// But idea_inbox.kind carries a CHECK constraint (migration 006) that only
+// admits the fixed task-kind enum, and a migration is out of this task's
+// touches[]. So we follow the exact precedent the sibling R70 feature set for
+// 'skill-friction' (see src/bongos/inbox.js SKILL_FRICTION_TAG): the row's kind
+// stays a valid enum value and a stable title prefix is the machine-checkable
+// marker. When GDS adds a real idea_inbox.kind migration, this prefix can be
+// promoted to a first-class kind and the marker collapses to a kind check.
+
+// Machine-checkable marker for onboarding-friction ideas. Mirrors
+// inbox.js's SKILL_FRICTION_TAG convention.
+const ONBOARDING_FRICTION_TAG = '[onboarding-friction]';
+
+// The underlying idea_inbox.kind these rows carry — a valid enum value
+// (idea_inbox CHECK). Friction surfaced from a transcript is a thing we
+// learned about the system, so 'learning-capture' is the honest kind.
+const ONBOARDING_FRICTION_KIND = 'learning-capture';
+
+// -------------------------------------------------------------------------
+// Transcript parsing
+//
+// A Claude Code transcript is JSONL: one JSON event per line. We only care
+// about user/assistant turns. Each turn's `message.content` is either a
+// string or an array of blocks ({type:'text'|'tool_use'|'tool_result', ...}).
+// tool_result blocks with is_error=true are the error signal; text blocks on
+// user turns are the human prompts. Everything is parsed defensively — a
+// malformed or unfamiliar line is skipped, never throws.
+// -------------------------------------------------------------------------
+
+function blockText(block) {
+  if (typeof block === 'string') return block;
+  if (block && typeof block === 'object') {
+    if (typeof block.text === 'string') return block.text;
+    // tool_result content can itself be a string or an array of text blocks.
+    if (block.type === 'tool_result') {
+      if (typeof block.content === 'string') return block.content;
+      if (Array.isArray(block.content)) {
+        return block.content.map(blockText).join(' ');
+      }
+    }
+  }
+  return '';
+}
+
+// A user message that carries only tool_result blocks is the harness feeding
+// tool output back to the model — NOT a human prompt. We want the real human
+// prompts for repeated-prompt detection, so we extract text blocks only when
+// the message isn't purely tool_result.
+function extractHumanPrompt(content) {
+  if (typeof content === 'string') return content.trim();
+  if (!Array.isArray(content)) return '';
+  const hasToolResult = content.some((b) => b && b.type === 'tool_result');
+  const hasNonToolResult = content.some(
+    (b) => b && b.type !== 'tool_result'
+  );
+  if (hasToolResult && !hasNonToolResult) return ''; // pure tool-output turn
+  return content
+    .filter((b) => !b || b.type !== 'tool_result')
+    .map(blockText)
+    .join('\n')
+    .trim();
+}
+
+function contentHasError(content) {
+  if (!Array.isArray(content)) return false;
+  return content.some(
+    (b) => b && b.type === 'tool_result' && b.is_error === true
+  );
+}
+
+// Strip <system-reminder>…</system-reminder> and similar machine-injected
+// wrappers so similarity/length heuristics see the human's actual words.
+function stripMachineNoise(text) {
+  return String(text || '')
+    .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, ' ')
+    .replace(/<command-[a-z-]+>[\s\S]*?<\/command-[a-z-]+>/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+// Parse JSONL → normalized turns. Returns { turns, meta }.
+//   turn = { role, text, ts, isError }
+// role is 'user' | 'assistant'. text is the human prompt (user) or the
+// assistant's visible text (assistant). isError flags a tool error on the turn.
+function parseTranscript(jsonlText) {
+  const lines = String(jsonlText || '').split('\n');
+  const turns = [];
+  let sessionId = null;
+  let firstTs = null;
+  let lastTs = null;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let evt;
+    try {
+      evt = JSON.parse(trimmed);
+    } catch (_) {
+      continue; // skip unparseable line
+    }
+    if (!evt || typeof evt !== 'object') continue;
+    if (!sessionId && typeof evt.sessionId === 'string') sessionId = evt.sessionId;
+    const ts = evt.timestamp || evt.message?.timestamp || null;
+    if (ts) {
+      if (!firstTs) firstTs = ts;
+      lastTs = ts;
+    }
+
+    const msg = evt.message;
+    const role = msg?.role || (evt.type === 'user' || evt.type === 'assistant' ? evt.type : null);
+    if (role !== 'user' && role !== 'assistant') continue;
+    const content = msg?.content ?? '';
+
+    if (role === 'user') {
+      const human = stripMachineNoise(extractHumanPrompt(content));
+      const isError = contentHasError(content);
+      // Keep the turn if it carries a human prompt OR an error result (so
+      // error-recovery counting sees it); drop pure-noise turns.
+      if (human || isError) {
+        turns.push({ role: 'user', text: human, ts, isError });
+      }
+    } else {
+      let text = '';
+      if (typeof content === 'string') text = content;
+      else if (Array.isArray(content)) {
+        text = content
+          .filter((b) => b && b.type === 'text')
+          .map(blockText)
+          .join('\n');
+      }
+      turns.push({ role: 'assistant', text: stripMachineNoise(text), ts, isError: false });
+    }
+  }
+
+  return {
+    turns,
+    meta: { sessionId, firstTs, lastTs, turnCount: turns.length },
+  };
+}
+
+// -------------------------------------------------------------------------
+// Deterministic friction signals
+//
+// Cheap, free, computed before (and fed into) the subagent. They pre-filter
+// obviously-clean sessions and give the subagent concrete evidence to anchor
+// on. Mirrors the family pipeline's "deterministic checks before Gemini" move.
+// -------------------------------------------------------------------------
+
+const LONG_RESPONSE_CHARS = 4000; // a notably long assistant turn
+const SIMILARITY_THRESHOLD = 0.6; // token-Jaccard above this = "repeated"
+const CORRECTION_RE = /\b(no|not|nope|wait|stop|wrong|actually|isn'?t|aren'?t|doesn'?t|didn'?t|won'?t|that'?s not|still|again|undo|revert|never\s?mind)\b/i;
+
+function tokenSet(text) {
+  return new Set(
+    String(text || '')
+      .toLowerCase()
+      .replace(/[^a-z0-9\s]/g, ' ')
+      .split(/\s+/)
+      .filter((w) => w.length > 2)
+  );
+}
+
+function jaccard(a, b) {
+  if (a.size === 0 || b.size === 0) return 0;
+  let inter = 0;
+  for (const t of a) if (b.has(t)) inter += 1;
+  const union = a.size + b.size - inter;
+  return union === 0 ? 0 : inter / union;
+}
+
+function detectFrictionSignals(turns) {
+  const humanPrompts = turns.filter((t) => t.role === 'user' && t.text);
+  const tokenSets = humanPrompts.map((t) => tokenSet(t.text));
+
+  // Repeated/similar prompts: count human prompts that closely echo an earlier
+  // one (the builder rephrasing because the first attempt didn't land).
+  let repeatedSimilarPrompts = 0;
+  const repeatedExamples = [];
+  for (let i = 1; i < tokenSets.length; i += 1) {
+    let best = 0;
+    let bestJ = -1;
+    for (let j = 0; j < i; j += 1) {
+      const s = jaccard(tokenSets[i], tokenSets[j]);
+      if (s > best) {
+        best = s;
+        bestJ = j;
+      }
+    }
+    if (best >= SIMILARITY_THRESHOLD) {
+      repeatedSimilarPrompts += 1;
+      if (repeatedExamples.length < 3) {
+        repeatedExamples.push({
+          similarity: Math.round(best * 100) / 100,
+          prompt: humanPrompts[i].text.slice(0, 200),
+          echoes: humanPrompts[bestJ].text.slice(0, 200),
+        });
+      }
+    }
+  }
+
+  // Long-then-correction: a long assistant response immediately followed by a
+  // corrective human prompt — the strongest "Claude answered but didn't
+  // resolve it" signal.
+  let longResponses = 0;
+  let longThenCorrection = 0;
+  const longExamples = [];
+  for (let i = 0; i < turns.length; i += 1) {
+    const t = turns[i];
+    if (t.role !== 'assistant' || t.text.length < LONG_RESPONSE_CHARS) continue;
+    longResponses += 1;
+    // Next human prompt after this response.
+    for (let k = i + 1; k < turns.length; k += 1) {
+      if (turns[k].role === 'user' && turns[k].text) {
+        if (CORRECTION_RE.test(turns[k].text)) {
+          longThenCorrection += 1;
+          if (longExamples.length < 3) {
+            longExamples.push({
+              response_chars: t.text.length,
+              followed_by: turns[k].text.slice(0, 200),
+            });
+          }
+        }
+        break;
+      }
+    }
+  }
+
+  // Error-recovery attempts: tool errors the session had to work past.
+  const errorRecoveryAttempts = turns.filter((t) => t.isError).length;
+
+  const score =
+    longThenCorrection * 2 + repeatedSimilarPrompts * 2 + Math.min(errorRecoveryAttempts, 6);
+  const flagged =
+    longThenCorrection >= 1 || repeatedSimilarPrompts >= 1 || errorRecoveryAttempts >= 3;
+
+  return {
+    longResponses,
+    longThenCorrection,
+    repeatedSimilarPrompts,
+    errorRecoveryAttempts,
+    humanPromptCount: humanPrompts.length,
+    score,
+    flagged,
+    examples: { repeated: repeatedExamples, longThenCorrection: longExamples },
+  };
+}
+
+// -------------------------------------------------------------------------
+// Subagent prompt + response validation
+// -------------------------------------------------------------------------
+
+// Cap the transcript text fed to the subagent so a marathon session can't
+// blow the context window or the bill. We compact to a role-tagged turn list
+// and truncate each turn; the deterministic signals carry the structural
+// evidence the truncation might drop.
+const MAX_PROMPT_CHARS = 60_000;
+const MAX_TURN_CHARS = 1_500;
+
+function compactTranscript(turns) {
+  const lines = [];
+  for (const t of turns) {
+    const tag = t.role === 'user' ? 'BUILDER' : 'CLAUDE';
+    let body = t.text || (t.isError ? '(tool error)' : '');
+    if (!body) continue;
+    if (body.length > MAX_TURN_CHARS) {
+      body = `${body.slice(0, MAX_TURN_CHARS)} …[${body.length - MAX_TURN_CHARS} more chars]`;
+    }
+    lines.push(`[${tag}]${t.isError ? ' (tool error)' : ''} ${body}`);
+  }
+  let text = lines.join('\n\n');
+  if (text.length > MAX_PROMPT_CHARS) {
+    // Keep the head and tail — onboarding friction tends to cluster at the
+    // start (confusion) and end (giving up / finally resolving).
+    const half = Math.floor(MAX_PROMPT_CHARS / 2);
+    text = `${text.slice(0, half)}\n\n…[middle elided]…\n\n${text.slice(-half)}`;
+  }
+  return text;
+}
+
+// The instance's project name, injected into the analysis prompt so a non-OTB
+// Cloud Bongos instance onboards against ITS OWN project rather than a hardcoded
+// "Off the Boats" (ADR 0062 §3/§5; the branding contract's llmProjectName field).
+// Resolved LAZILY (inside the header builder, not at module load) so this module
+// stays side-effect-free at require time — it is the *pure* half of the pipeline.
+// Falls back to a neutral phrase if branding fails to resolve.
+function llmProjectName() {
+  try { return require('../../src/module-api').branding().llmProjectName || 'this project'; }
+  catch { return 'this project'; }
+}
+
+const analysisHeader = () => `You are reviewing one Claude Code session transcript from a NEW builder being onboarded onto the ${llmProjectName()} project. Your job is to detect moments of FRICTION — places where the builder was confused, blocked, or where the system made onboarding harder than it should be. This is "feedback without asking": the builder consented to this analysis so we can improve onboarding instead of interrogating them.
+
+Look specifically for:
+- long Claude responses that did NOT resolve the builder's question (the builder pushes back, repeats, or corrects right after a wall of text)
+- the builder asking the same thing two or more times in different words (a sign the answer never landed)
+- error-recovery loops (commands or tool calls that failed and had to be retried)
+- the builder expressing confusion, frustration, or "I don't understand how X works"
+
+You are given deterministic signals computed from the transcript (counts of the above) plus a compacted transcript. Use the signals as anchors but make your own judgement from the transcript text.
+
+Return ONLY JSON matching this schema — no prose, no markdown fences:
+{
+  "flagged": <boolean>,            // true if this session contains real onboarding friction worth acting on
+  "confidence": <number 0-1>,      // your confidence in the flagged decision
+  "summary": <string>,             // 2-4 line plain-English summary of what tripped the builder up (or why it was smooth)
+  "friction_moments": [            // empty array if flagged=false
+    {
+      "kind": "long_unresolved" | "repeated_prompt" | "error_recovery" | "confusion" | "other",
+      "evidence": <string>,        // short quote or paraphrase from the transcript
+      "suggestion": <string>       // one concrete way onboarding could remove this friction
+    }
+  ]
+}
+
+Be specific and concrete. A flagged=true with an empty friction_moments array is not useful. If the session was genuinely smooth, return flagged=false with a one-line summary.`;
+
+function buildAnalysisPrompt({ sessionMeta = {}, signals = {}, turns = [] }) {
+  const lines = [];
+  lines.push(analysisHeader());
+  lines.push('');
+  lines.push('---');
+  lines.push('## Session');
+  lines.push(`session_id: ${sessionMeta.sessionId || '(unknown)'}`);
+  lines.push(`turns: ${sessionMeta.turnCount ?? turns.length}`);
+  if (sessionMeta.firstTs) lines.push(`started: ${sessionMeta.firstTs}`);
+  lines.push('');
+  lines.push('## Deterministic signals');
+  lines.push('```json');
+  lines.push(
+    JSON.stringify(
+      {
+        longResponses: signals.longResponses,
+        longThenCorrection: signals.longThenCorrection,
+        repeatedSimilarPrompts: signals.repeatedSimilarPrompts,
+        errorRecoveryAttempts: signals.errorRecoveryAttempts,
+        humanPromptCount: signals.humanPromptCount,
+      },
+      null,
+      2
+    )
+  );
+  lines.push('```');
+  lines.push('');
+  lines.push('## Compacted transcript');
+  lines.push('');
+  lines.push(compactTranscript(turns));
+  lines.push('');
+  lines.push('Now analyze. Output ONLY the JSON object — nothing before or after it.');
+  return lines.join('\n');
+}
+
+// Tolerant JSON extraction — same approach grader.js uses (models sometimes
+// wrap JSON in fences or add a stray line).
+function extractJson(raw) {
+  if (raw && typeof raw === 'object') return raw;
+  if (typeof raw !== 'string') return null;
+  const fenced = /```(?:json)?\s*\n?([\s\S]*?)```/.exec(raw);
+  const candidate = (fenced ? fenced[1] : raw).trim();
+  const first = candidate.indexOf('{');
+  const last = candidate.lastIndexOf('}');
+  if (first < 0 || last < 0 || last <= first) return null;
+  try {
+    return JSON.parse(candidate.slice(first, last + 1));
+  } catch (_) {
+    return null;
+  }
+}
+
+const VALID_MOMENT_KINDS = [
+  'long_unresolved',
+  'repeated_prompt',
+  'error_recovery',
+  'confusion',
+  'other',
+];
+
+// Normalize the subagent response into a stable shape. Never throws — a
+// malformed response returns { ok:false, flagged:false } so the caller can
+// decide to fall back to deterministic signals.
+function validateAnalysis(raw) {
+  const parsed = extractJson(raw);
+  if (!parsed || typeof parsed !== 'object') {
+    return { ok: false, flagged: false, confidence: 0, summary: '', friction_moments: [], parse_error: true };
+  }
+  const confidence = Number.isFinite(Number(parsed.confidence))
+    ? Math.max(0, Math.min(1, Number(parsed.confidence)))
+    : null;
+  const moments = Array.isArray(parsed.friction_moments)
+    ? parsed.friction_moments
+        .filter((m) => m && typeof m === 'object')
+        .slice(0, 20)
+        .map((m) => ({
+          kind: VALID_MOMENT_KINDS.includes(m.kind) ? m.kind : 'other',
+          evidence: String(m.evidence || '').slice(0, 500),
+          suggestion: String(m.suggestion || '').slice(0, 500),
+        }))
+    : [];
+  return {
+    ok: true,
+    flagged: parsed.flagged === true,
+    confidence,
+    summary: String(parsed.summary || '').slice(0, 2000),
+    friction_moments: moments,
+  };
+}
+
+// -------------------------------------------------------------------------
+// idea_inbox payload
+// -------------------------------------------------------------------------
+
+function shortSession(sessionId) {
+  if (!sessionId) return 'unknown-session';
+  return String(sessionId).slice(0, 8);
+}
+
+// Build the { title, body_md, kind } payload for POST /api/gds/inbox. The
+// title carries ONBOARDING_FRICTION_TAG so triage (and the future kind
+// migration) can find these rows; the body holds the subagent summary, each
+// friction moment, and the deterministic signals as an audit trail.
+function buildIdeaPayload({ sessionMeta = {}, analysis, signals = {} }) {
+  const sid = shortSession(sessionMeta.sessionId);
+  const moments = analysis?.friction_moments || [];
+  const n = moments.length;
+  const title = `${ONBOARDING_FRICTION_TAG} session ${sid} — ${n} friction moment${n === 1 ? '' : 's'}`.slice(0, 200);
+
+  const lines = [];
+  lines.push(`Auto-filed from a consented onboarding session transcript (V3.R79 / C1 — feedback without asking).`);
+  lines.push('');
+  lines.push(`**Session:** \`${sessionMeta.sessionId || '(unknown)'}\``);
+  if (sessionMeta.firstTs) lines.push(`**Started:** ${sessionMeta.firstTs}`);
+  lines.push(`**Turns:** ${sessionMeta.turnCount ?? '?'}`);
+  if (analysis?.confidence != null) lines.push(`**Subagent confidence:** ${analysis.confidence}`);
+  lines.push('');
+  if (analysis?.summary) {
+    lines.push('### Summary');
+    lines.push(analysis.summary.trim());
+    lines.push('');
+  }
+  if (n > 0) {
+    lines.push('### Friction moments');
+    for (const m of moments) {
+      lines.push(`- **${m.kind}** — ${m.evidence}`);
+      if (m.suggestion) lines.push(`  - _suggestion:_ ${m.suggestion}`);
+    }
+    lines.push('');
+  }
+  lines.push('### Deterministic signals');
+  lines.push('```json');
+  lines.push(
+    JSON.stringify(
+      {
+        longResponses: signals.longResponses,
+        longThenCorrection: signals.longThenCorrection,
+        repeatedSimilarPrompts: signals.repeatedSimilarPrompts,
+        errorRecoveryAttempts: signals.errorRecoveryAttempts,
+        humanPromptCount: signals.humanPromptCount,
+        score: signals.score,
+      },
+      null,
+      2
+    )
+  );
+  lines.push('```');
+  lines.push('');
+  lines.push('_Raw transcript was NOT uploaded — only this distilled friction signal. Filed during the builder\'s onboarding window with explicit consent._');
+
+  return {
+    title,
+    body_md: lines.join('\n'),
+    kind: ONBOARDING_FRICTION_KIND,
+  };
+}
+
+module.exports = {
+  ONBOARDING_FRICTION_TAG,
+  ONBOARDING_FRICTION_KIND,
+  // parsing
+  parseTranscript,
+  stripMachineNoise,
+  // signals
+  detectFrictionSignals,
+  LONG_RESPONSE_CHARS,
+  SIMILARITY_THRESHOLD,
+  // subagent
+  buildAnalysisPrompt,
+  compactTranscript,
+  extractJson,
+  validateAnalysis,
+  VALID_MOMENT_KINDS,
+  // payload
+  buildIdeaPayload,
+};

package/modules/onboarding/port.js

@@ -0,0 +1,63 @@
+'use strict';
+
+// modules/onboarding/port.js — the `onboarding` kernel PORT provider surface
+// (BV1.R81 / ADR 0093 §1).
+//
+// onboarding owns admission · the newcomer onboarding state machine · the
+// evergreen-chore restock. Two of those surfaces are reached HTTP-side through
+// the module's own routes (routes/onboarding.js mounts the access-requests
+// admission endpoints). But several CORE files legitimately need a sliver of the
+// STATE-MACHINE + RESTOCK surface and must NOT `require()` a module (the one-way
+// boundary, ADR 0083). They resolve THIS port instead:
+//   • src/bongos/db.js (lifecycle) — claimTask/shipTask tick the onboarding state
+//     machine INSIDE their transaction (`markStage`) and fire the graduation
+//     broadcast after COMMIT (`broadcastGraduation`). This is the core→module
+//     direction the economy `reward` port already established.
+//   • src/bongos/auth.js — the Device-Flow + web auth callbacks mark `auth_complete`
+//     (`safeMarkStage`).
+//   • src/bongos/routes/me.js — the GET /me aggregator reads + shapes the builder's
+//     onboarding checklist (`getState`/`shapeForApi`) and PATCH /me/disciplines
+//     marks `pick_disciplines` (`safeMarkStage`).
+//   • src/bongos/routes/builders.js — GET /builders/:id/onboarding reads + shapes the
+//     roster-visible checklist (`getState`/`shapeForApi`).
+//   • src/bongos/routes/tasks.js — GET /tasks/claimable marks `first_start`
+//     (`safeMarkStage`); POST /tasks/newcomer-restock is the Archon backstop
+//     (`restockAll`); a chore claim restocks its shelf (`restockForClaim`,
+//     `SOURCE_TAG`).
+//   • src/bongos/routes/claims.js — POST /claims restocks the newcomer-chore shelf
+//     the instant one is claimed (`restockForClaim`, `SOURCE_TAG`).
+//
+// onboarding is default-on, so the provider is present in prod; every consumer
+// degrades gracefully when it isn't (a vanilla instance without the module): the
+// state-machine ticks become best-effort no-ops and the restock is skipped (the
+// chore shelf simply isn't maintained), exactly as the surrounding try/catch
+// already tolerated.
+//
+// We DELEGATE (do not spread) every method so a test that stubs a function on the
+// live onboarding-state / newcomer-restock module object still bites at call time
+// (the economy reward.js / builder-settings settings.js precedent — a spread
+// captures the original reference at module-load).
+
+const onboardingState = require('./onboarding-state');
+const newcomerRestock = require('./newcomer-restock');
+
+module.exports = {
+  // --- the newcomer onboarding state machine (onboarding-state.js) ---------
+  // read + shape the builder's checklist (me.js / builders.js).
+  getState: (...a) => onboardingState.getState(...a),
+  shapeForApi: (...a) => onboardingState.shapeForApi(...a),
+  // mark a stage; safeMarkStage swallows errors + fires the graduation broadcast
+  // (auth.js / me.js / tasks.js). markStage is the raw, transaction-participant
+  // form the lifecycle (db.js) runs inside its own BEGIN/COMMIT.
+  safeMarkStage: (...a) => onboardingState.safeMarkStage(...a),
+  markStage: (...a) => onboardingState.markStage(...a),
+  broadcastGraduation: (...a) => onboardingState.broadcastGraduation(...a),
+
+  // --- the evergreen newcomer-chore restock (newcomer-restock.js) ----------
+  // restock the just-claimed chore's shelf (claims.js / tasks.js); the Archon
+  // backstop tops every chore up (tasks.js). SOURCE_TAG is the marker the claim
+  // path tests a task against before restocking.
+  restockForClaim: (...a) => newcomerRestock.restockForClaim(...a),
+  restockAll: (...a) => newcomerRestock.restockAll(...a),
+  SOURCE_TAG: newcomerRestock.SOURCE_TAG,
+};