@juzser/blacksmith 0.4.0 → 0.5.0

package/factory/orchestrator/dist/waveConcurrency.js

@@ -1,4 +1,6 @@
-import { foldAgents } from './agents-registry.js';
+import { DISPATCH_EVENT_TYPE, foldAgents } from './agents-registry.js';
+import { eventTaskId } from './events.js';
+import { epicOfTaskId, isQualifiedTaskId, taskIdsMatch } from './taskId.js';
 /**
  * Did the wave that was admitted N wide actually run N wide?
  *
@@ -24,6 +26,7 @@ import { foldAgents } from './agents-registry.js';
  * intervals open forever and score every wave after one as parallel.
  */
 const ADMITTED_EVENT_TYPE = 'wave-admitted';
+const MERGED_EVENT_TYPE = 'wave-merged';
 /**
  * What the log says a wave did.
  *
@@ -33,12 +36,29 @@ const ADMITTED_EVENT_TYPE = 'wave-admitted';
  * - `single`     — the wave admitted one task. Nothing to be parallel about,
  *                  and scoring it against a width it never claimed would make
  *                  the failing verdicts unreadable.
+ * - `unlinked`   — this fold's intervals hold nothing, but the lineage still
+ *                  has proof the work happened: a `wave-merged` for one of
+ *                  the admitted tasks, or a `dispatch_decision` parented
+ *                  directly on the admission. A wave-runner session started
+ *                  without `--continues` has `causal_parent: null` on its
+ *                  root, so its own dispatch_decisions never reach this fold
+ *                  even though its agents genuinely ran. Width is unmeasured
+ *                  here, not zero — a different fact from `unobserved`, which
+ *                  is exactly why it is not folded into it.
  * - `unobserved` — the wave was admitted and the log records no work for any
- *                  of its tasks. Not the same fact as `serialized`, and the
+ *                  of its tasks, and nothing else on the lineage says
+ *                  otherwise. Not the same fact as `serialized`, and the
  *                  whole point of separating them: one says the factory ran
  *                  narrow, the other says nobody can tell.
  */
-export const WAVE_VERDICTS = ['parallel', 'partial', 'serialized', 'single', 'unobserved'];
+export const WAVE_VERDICTS = [
+    'parallel',
+    'partial',
+    'serialized',
+    'single',
+    'unlinked',
+    'unobserved',
+];
 /**
  * A counter with one bucket per key, all at zero.
  *
@@ -61,6 +81,17 @@ export function zeroedCounts(keys) {
 export const UNOBSERVED_HINT = 'A wave admitted with no dispatch_decision under any of its tasks ran nowhere this log can ' +
     'see. Either the dispatcher never started it, or the agents ran outside the lineage that was ' +
     'read — narrow with --epic, or check that the run wrote its dispatches to this state dir.';
+/**
+ * Said when a wave came back `unlinked`: this fold has no dispatch interval
+ * for it, but the lineage holds a `wave-merged` for one of its tasks or a
+ * dispatch_decision parented on the admission itself, so the work is real —
+ * only its width is unmeasured. The usual cause is a wave-runner session
+ * started without `--continues`, which leaves its own dispatches outside the
+ * lineage this read walks even though they ran.
+ */
+export const UNLINKED_HINT = 'A wave admitted with merged work or a dispatch on record, but not inside this lineage, so ' +
+    'its width cannot be measured. Likely a wave-runner session started without --continues — ' +
+    'its dispatches are real but outside the chain this read walked.';
 function readAdmission(event) {
     const payload = event.record.payload;
     const raw = payload.task_ids;
@@ -119,17 +150,109 @@ function peakOverlap(runs) {
     }
     return peak;
 }
-function verdictFor(declared, observed, peak) {
+function verdictFor(declared, observed, peak, offLineageEvidence) {
     if (declared <= 1)
         return 'single';
-    if (observed === 0)
+    if (observed === 0) {
+        if (offLineageEvidence)
+            return 'unlinked';
         return 'unobserved';
+    }
     if (peak >= declared)
         return 'parallel';
     if (peak <= 1)
         return 'serialized';
     return 'partial';
 }
+/**
+ * Whether `admission` is the one a `wave-merged` id names.
+ *
+ * A qualified id ("A/task-1") must match the admission's epic exactly — no
+ * falling back to the bare half, because that fallback is exactly how a bare
+ * merge under one epic used to mark an unrelated epic's qualified admission
+ * as having merge evidence. A bare id ("task-1") carries no epic of its own,
+ * so it may match any admission's declared task by its bare half; which
+ * admission it actually belongs to is for {@link latestMatchingAdmission} to
+ * decide, not this predicate.
+ */
+function admissionClaims(admission, mergedId) {
+    if (isQualifiedTaskId(mergedId) && epicOfTaskId(mergedId) !== admission.epicId)
+        return false;
+    return admission.taskIds.some((taskId) => taskIdsMatch(taskId, mergedId));
+}
+/**
+ * The one admission a `wave-merged` id belongs to: the latest whose `ts` is
+ * at or before the merge's `ts` and whose declared tasks match it — the same
+ * "nearest preceding admission" rule `admittedAtByTask` uses to close a
+ * task's window, reused here rather than re-derived, so a task re-admitted in
+ * a later wave sends its merge to that wave and not the one before it. A
+ * merge timestamped before every candidate admission belongs to none of them;
+ * returning null rather than the earliest is what keeps that merge from
+ * counting at all.
+ */
+function latestMatchingAdmission(mergedId, mergeTs, admissions) {
+    let best = null;
+    for (const admission of admissions) {
+        if (admission.ts > mergeTs)
+            continue;
+        if (!admissionClaims(admission, mergedId))
+            continue;
+        if (best === null || admission.ts > best.ts)
+            best = admission;
+    }
+    return best;
+}
+/**
+ * The `wave-admitted` event ids that own at least one `wave-merged` id,
+ * attributed one merge at a time over the whole log so each admission can ask
+ * "is my work here" without rescanning — and so an admission the epic filter
+ * excludes must not narrow what another admission can see.
+ *
+ * Both the envelope's `task_id` and the payload's `task_ids` are read,
+ * because `emitWaveMerged` writes the same id to both; either is enough.
+ */
+function admissionsWithMergeEvidence(events, admissions) {
+    const credited = new Set();
+    for (const event of events) {
+        if (event.record.event_type !== MERGED_EVENT_TYPE)
+            continue;
+        const ids = [];
+        const fromEnvelope = eventTaskId(event.record);
+        if (fromEnvelope)
+            ids.push(fromEnvelope);
+        const payload = event.record.payload;
+        if (Array.isArray(payload?.task_ids)) {
+            for (const id of payload.task_ids) {
+                if (typeof id === 'string' && id.length > 0)
+                    ids.push(id);
+            }
+        }
+        for (const id of ids) {
+            const owner = latestMatchingAdmission(id, event.record.ts, admissions);
+            if (owner)
+                credited.add(owner.eventId);
+        }
+    }
+    return credited;
+}
+/**
+ * The `wave-admitted` event ids that a `dispatch_decision` names as its
+ * direct causal parent — the shape a wave-runner's own agent takes when it is
+ * dispatched straight off the admission rather than through a task. Read from
+ * raw events rather than `foldAgents`, because that fold only keeps agents
+ * with a task id, and this dispatch has none.
+ */
+function dispatchedDirectlyOn(events) {
+    const parents = new Set();
+    for (const event of events) {
+        if (event.record.event_type !== DISPATCH_EVENT_TYPE)
+            continue;
+        const parent = event.record.causal_parent;
+        if (typeof parent === 'string' && parent.length > 0)
+            parents.add(parent);
+    }
+    return parents;
+}
 /**
  * Fold one task's agents into the interval it was worked on. Every role counts,
  * not just the coder's: a task whose reviewer is still running is still work
@@ -199,6 +322,14 @@ export function auditWaveConcurrency(events, options = {}) {
         else
             agentsByTask.set(agent.taskId, [agent]);
     }
+    // Also built from every event, unfiltered: off-lineage evidence for a wave
+    // the caller narrowed away must not leak in, but an admission's own window
+    // must see all of it regardless of which epic the caller asked for. Merge
+    // attribution needs every admission as a candidate, not just the ones the
+    // caller's epic filter kept — the same reason `admissions` above is built
+    // before that filter is applied.
+    const mergeCredited = admissionsWithMergeEvidence(events, admissions);
+    const directDispatchParents = dispatchedDirectlyOn(events);
     const waves = [];
     for (const admission of admissions) {
         if (options.epicId !== undefined && admission.epicId !== options.epicId)
@@ -219,6 +350,7 @@ export function auditWaveConcurrency(events, options = {}) {
         }
         observed.sort((a, b) => a.startedAt.localeCompare(b.startedAt));
         const peak = peakOverlap(observed);
+        const offLineageEvidence = directDispatchParents.has(admission.eventId) || mergeCredited.has(admission.eventId);
         waves.push({
             eventId: admission.eventId,
             admittedAt: admission.ts,
@@ -227,7 +359,7 @@ export function auditWaveConcurrency(events, options = {}) {
             observed,
             unobserved,
             peak,
-            verdict: verdictFor(admission.taskIds.length, observed.length, peak),
+            verdict: verdictFor(admission.taskIds.length, observed.length, peak, offLineageEvidence),
         });
     }
     return waves;
@@ -264,16 +396,20 @@ function labelsWith(waves, verdict) {
 export function summariseWaveConcurrency(waves) {
     const serialized = labelsWith(waves, 'serialized');
     const unobserved = labelsWith(waves, 'unobserved');
+    const unlinked = labelsWith(waves, 'unlinked');
     return {
         waves: [...waves],
         serialized,
         partial: labelsWith(waves, 'partial'),
         unobserved,
+        unlinked,
         widest: {
             declared: waves.reduce((max, wave) => Math.max(max, wave.declared.length), 0),
             observed: waves.reduce((max, wave) => Math.max(max, wave.peak), 0),
         },
-        hint: unobserved.length > 0 ? UNOBSERVED_HINT : '',
+        hint: unobserved.length > 0 ? UNOBSERVED_HINT : unlinked.length > 0 ? UNLINKED_HINT : '',
+        // `unlinked` is real work off-lineage, not a failure to judge, so it never
+        // worsens the exit code the way `unobserved` does.
         exitCode: serialized.length > 0 ? 1 : unobserved.length > 0 ? 2 : 0,
     };
 }

package/factory/orchestrator/dist/workroot.js

@@ -37,7 +37,7 @@ const WORK_DIRS = [
  * the roadmap and the stack answers are declarations the operator made, and a
  * team sharing the repository should share them.
  */
-const WORK_ROOT_GITIGNORE = `# Written by \`smith init\`. Blacksmith's state is a cache of its event log
+const WORK_ROOT_GITIGNORE = `# Written by \`bs init\`. Blacksmith's state is a cache of its event log
 # and belongs to this machine; the answers under factory/ are declarations
 # this project made, so they are tracked.
 state/

package/factory/orchestrator/dist/worktree.js

@@ -3,7 +3,7 @@ import { SmithError } from './errors.js';
 import { runGit as git } from './git.js';
 export class WorktreeError extends SmithError {
 }
-/** The task-id segment reserved for an epic's integration branch (smith/<epic>/integration) —
+/** The task-id segment reserved for an epic's integration branch (<prefix>/<epic>/integration) —
  * never a real task. Exported for db/projector.ts's foldTasks() guard and epic.ts's
  * runEpicVerdict(), both of which need to recognise `<epic>/integration` as non-task. */
 export const RESERVED_TASK_ID = 'integration';
@@ -16,6 +16,19 @@ function localBranchExists(projectDir, branch) {
         return false;
     }
 }
+/**
+ * Whether a task's own branch (`taskBranchName`) already exists locally —
+ * i.e. whether the task has already been cut. Exported for cli.ts's
+ * `worktree create --from` guard: spec.ts's `successorChainPath` hands back
+ * the bare hop ids between a `--from` predecessor and its target purely from
+ * the event log, with no notion of git state; this is the git-aware
+ * predicate the guard pairs it with to refuse skipping past a hop that was
+ * already cut (`createTaskWorktree` branches straight off `--from`'s own
+ * branch, so a cut hop's commits would otherwise vanish silently).
+ */
+export function taskBranchExists(projectDir, epic, taskId) {
+    return localBranchExists(projectDir, taskBranchName(epic, taskId, epicBranchPrefix(projectDir, epic)));
+}
 /**
  * Best-effort default-branch detection: origin/HEAD symbolic ref first (the
  * normal case after a clone), then whatever branch is currently checked out,
@@ -92,13 +105,39 @@ export function taskWorktreeDir(projectDir, epic, taskId) {
     const project = path.resolve(projectDir);
     return path.join(path.dirname(project), '.wt', path.basename(project), bareTaskId(epic, taskId));
 }
-/** `smith/<epic>/integration` — the one branch an epic assembles onto. Exported for
- * integration.ts, which runs the check suite against it (D-42/P9-26). */
-export function integrationBranchName(epic) {
-    return `smith/${epic}/integration`;
+/** The branch prefix every new epic gets (bs-rename operator decision 1). */
+export const BRANCH_PREFIX = 'bs';
+/** The prefix `BRANCH_PREFIX` replaced. Still recognised so an epic already
+ * cut under it keeps landing new branches there (operator decision 3) rather
+ * than splitting one epic's worktrees across two branch families. */
+export const LEGACY_BRANCH_PREFIX = 'smith';
+/**
+ * Which prefix THIS epic's factory branches use: `smith` when
+ * `smith/<epic>/integration` already exists locally, `bs` otherwise —
+ * including for a brand-new epic, which has neither yet. Git-aware on
+ * purpose: this is the one place that decides, so integrationBranchName and
+ * taskBranchName can stay pure string joins driven by whatever prefix their
+ * caller resolved (or hands the bs default straight through, for the
+ * git-free callers — taskEvents.ts and db/projector.ts's fallback — that
+ * have no projectDir to ask).
+ */
+export function epicBranchPrefix(projectDir, epic) {
+    return localBranchExists(projectDir, `${LEGACY_BRANCH_PREFIX}/${epic}/${RESERVED_TASK_ID}`)
+        ? LEGACY_BRANCH_PREFIX
+        : BRANCH_PREFIX;
+}
+/** `<prefix>/<epic>/integration` — the one branch an epic assembles onto.
+ * `prefix` defaults to BRANCH_PREFIX (`bs`); a caller with a projectDir
+ * passes `epicBranchPrefix(projectDir, epic)` to get the epic's actual
+ * prefix, legacy `smith/` included. Exported for integration.ts, which runs
+ * the check suite against it (D-42/P9-26). */
+export function integrationBranchName(epic, prefix = BRANCH_PREFIX) {
+    return `${prefix}/${epic}/integration`;
 }
 /**
- * `smith/<epic>/<bare-task-id>` — the branch convention, defined once.
+ * `<prefix>/<epic>/<bare-task-id>` — the branch convention, defined once.
+ * `prefix` defaults to BRANCH_PREFIX (`bs`) for the same reason as
+ * integrationBranchName above.
  *
  * D-23/P9-12: exported because three places need to agree on it — this module
  * (which creates the branch), taskEvents.ts's `task-added` (which declares it
@@ -108,14 +147,14 @@ export function integrationBranchName(epic) {
  *
  * A task_id already embeds its epic ("epic-7/task-142", findings.ts's
  * convention) so strip that prefix before rejoining — concatenating epic +
- * full task_id double-embeds it (smith/epic-7/epic-7/task-142). The CLI hands
+ * full task_id double-embeds it (bs/epic-7/epic-7/task-142). The CLI hands
  * this whatever the operator typed, so both shapes really do arrive.
  */
-export function taskBranchName(epic, taskId) {
-    return `smith/${epic}/${bareTaskId(epic, taskId)}`;
+export function taskBranchName(epic, taskId, prefix = BRANCH_PREFIX) {
+    return `${prefix}/${epic}/${bareTaskId(epic, taskId)}`;
 }
 function ensureIntegrationBranch(projectDir, epic) {
-    const branch = integrationBranchName(epic);
+    const branch = integrationBranchName(epic, epicBranchPrefix(projectDir, epic));
     if (!localBranchExists(projectDir, branch)) {
         const defaultBranch = detectDefaultBranch(projectDir);
         git(projectDir, ['branch', branch, defaultBranch]);
@@ -127,11 +166,12 @@ function ensureIntegrationBranch(projectDir, epic) {
  * sibling of whatever directory the project was handed as, never a path of
  * this module's own choosing, so a project outside this clone keeps its
  * worktrees outside it too (see taskWorktreeDir)
- * on branch smith/<epic>/<task-id>.
+ * on branch <prefix>/<epic>/<task-id>, where <prefix> is epicBranchPrefix's
+ * answer for this epic (`bs`, or `smith` for an epic already cut under it).
  *
- * Without `opts.from`, cut from the CURRENT head of smith/<epic>/integration
+ * Without `opts.from`, cut from the CURRENT head of <prefix>/<epic>/integration
  * (creating the integration branch from the default branch first if it
- * doesn't exist yet). With `opts.from`, cut from smith/<epic>/<from> instead
+ * doesn't exist yet). With `opts.from`, cut from <prefix>/<epic>/<from> instead
  * — the predecessor's branch, commits and all — and integration is never
  * consulted.
  */
@@ -139,11 +179,12 @@ export function createTaskWorktree(projectDir, epic, taskId, opts = {}) {
     if (taskId === RESERVED_TASK_ID) {
         throw new WorktreeError('worktree.reserved-task-id', `Task id "${RESERVED_TASK_ID}" is reserved for the integration branch itself.`, { taskId });
     }
-    const branch = taskBranchName(epic, taskId);
+    const prefix = epicBranchPrefix(projectDir, epic);
+    const branch = taskBranchName(epic, taskId, prefix);
     const worktreeDir = taskWorktreeDir(projectDir, epic, taskId);
     let sourceBranch;
     if (opts.from !== undefined) {
-        sourceBranch = taskBranchName(epic, opts.from);
+        sourceBranch = taskBranchName(epic, opts.from, prefix);
         if (!localBranchExists(projectDir, sourceBranch)) {
             throw new WorktreeError('worktree.from-missing', `Predecessor branch ${sourceBranch} does not exist; cannot cut ${taskId} from it.`, { epic, taskId, from: opts.from, branch: sourceBranch });
         }
@@ -157,7 +198,7 @@ export function createTaskWorktree(projectDir, epic, taskId, opts = {}) {
 /** Remove a task's worktree and its local branch after it has merged. */
 export function removeTaskWorktree(projectDir, epic, taskId) {
     const worktreeDir = taskWorktreeDir(projectDir, epic, taskId);
-    const branch = taskBranchName(epic, taskId);
+    const branch = taskBranchName(epic, taskId, epicBranchPrefix(projectDir, epic));
     try {
         git(projectDir, ['worktree', 'remove', worktreeDir]);
     }
@@ -193,12 +234,13 @@ function parseWorktreePorcelain(output) {
     return entries;
 }
 /**
- * List task worktrees whose branch is fully merged into smith/<epic>/integration.
+ * List task worktrees whose branch is fully merged into <prefix>/<epic>/integration.
  * Reports only — never deletes.
  */
 export function listStale(projectDir, epic) {
-    const integrationBranch = integrationBranchName(epic);
-    const prefix = `smith/${epic}/`;
+    const branchPrefix = epicBranchPrefix(projectDir, epic);
+    const integrationBranch = integrationBranchName(epic, branchPrefix);
+    const prefix = `${branchPrefix}/${epic}/`;
     const porcelain = git(projectDir, ['worktree', 'list', '--porcelain']);
     const entries = parseWorktreePorcelain(porcelain);
     const stale = [];

package/factory/orchestrator/drizzle/0013_operator_feedback.sql

@@ -0,0 +1,19 @@
+CREATE TABLE `operator_feedback` (
+	`id` text PRIMARY KEY NOT NULL,
+	`task_id` text NOT NULL,
+	`session_id` text NOT NULL,
+	`body` text NOT NULL,
+	`kind` text NOT NULL,
+	`source` text NOT NULL,
+	`external_id` text,
+	`author` text,
+	`recorded_at` text NOT NULL,
+	`recorded_event_id` text NOT NULL,
+	`resolved_at` text,
+	`resolution` text,
+	`follow_up_task_id` text
+);
+--> statement-breakpoint
+CREATE INDEX `operator_feedback_task_idx` ON `operator_feedback` (`task_id`);--> statement-breakpoint
+CREATE INDEX `operator_feedback_session_idx` ON `operator_feedback` (`session_id`);--> statement-breakpoint
+CREATE INDEX `operator_feedback_external_idx` ON `operator_feedback` (`external_id`);

package/factory/orchestrator/drizzle/0014_misty_madripoor.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `tasks` ADD `title` text;--> statement-breakpoint
+ALTER TABLE `tasks` ADD `summary` text;

package/factory/orchestrator/drizzle/0015_gifted_omega_flight.sql

@@ -0,0 +1 @@
+ALTER TABLE `tasks` ADD `terminal_at` text;

package/factory/orchestrator/drizzle/0016_milestones_project_default.sql

@@ -0,0 +1,30 @@
+PRAGMA foreign_keys=OFF;--> statement-breakpoint
+CREATE TABLE `__new_milestones` (
+	`milestone_id` text PRIMARY KEY NOT NULL,
+	`name` text NOT NULL,
+	`status` text NOT NULL,
+	`sequence` integer NOT NULL,
+	`goal` text,
+	`epic_ids` text NOT NULL,
+	`project` text DEFAULT 'blacksmith' NOT NULL,
+	`kind` text DEFAULT 'factory' NOT NULL,
+	`error_issues` integer DEFAULT true NOT NULL
+);
+--> statement-breakpoint
+INSERT INTO `__new_milestones`("milestone_id", "name", "status", "sequence", "goal", "epic_ids", "project", "kind", "error_issues") SELECT "milestone_id", "name", "status", "sequence", "goal", "epic_ids", "project", "kind", "error_issues" FROM `milestones`;--> statement-breakpoint
+DROP TABLE `milestones`;--> statement-breakpoint
+ALTER TABLE `__new_milestones` RENAME TO `milestones`;--> statement-breakpoint
+PRAGMA foreign_keys=ON;--> statement-breakpoint
+CREATE INDEX `milestones_project_idx` ON `milestones` (`project`);--> statement-breakpoint
+-- The factory's own project was renamed from 'black-smith' to 'blacksmith'.
+-- History (events, committed plan files, old roadmap.md bullets) keeps the
+-- old spelling, but every table's read model should not: rewrite every row
+-- that already carries the old name in every table with a project column.
+UPDATE `events_raw` SET `project` = 'blacksmith' WHERE `project` = 'black-smith';--> statement-breakpoint
+UPDATE `dispatches` SET `project` = 'blacksmith' WHERE `project` = 'black-smith';--> statement-breakpoint
+UPDATE `tasks` SET `project` = 'blacksmith' WHERE `project` = 'black-smith';--> statement-breakpoint
+UPDATE `errors` SET `project` = 'blacksmith' WHERE `project` = 'black-smith';--> statement-breakpoint
+UPDATE `findings` SET `project` = 'blacksmith' WHERE `project` = 'black-smith';--> statement-breakpoint
+UPDATE `epics` SET `project` = 'blacksmith' WHERE `project` = 'black-smith';--> statement-breakpoint
+UPDATE `milestones` SET `project` = 'blacksmith' WHERE `project` = 'black-smith';--> statement-breakpoint
+UPDATE `issue_reports` SET `project` = 'blacksmith' WHERE `project` = 'black-smith';

package/factory/orchestrator/drizzle/0017_events_raw_cli_session_id.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `events_raw` ADD `cli_session_id` text;--> statement-breakpoint
+CREATE INDEX `events_raw_cli_session_idx` ON `events_raw` (`cli_session_id`);

package/factory/orchestrator/drizzle/meta/_journal.json

@@ -92,6 +92,41 @@
       "when": 1789464480602,
       "tag": "0012_issue_reports_error_issues",
       "breakpoints": true
+    },
+    {
+      "idx": 13,
+      "version": "6",
+      "when": 1790738459253,
+      "tag": "0013_operator_feedback",
+      "breakpoints": true
+    },
+    {
+      "idx": 14,
+      "version": "6",
+      "when": 1790818969124,
+      "tag": "0014_misty_madripoor",
+      "breakpoints": true
+    },
+    {
+      "idx": 15,
+      "version": "6",
+      "when": 1790924037810,
+      "tag": "0015_gifted_omega_flight",
+      "breakpoints": true
+    },
+    {
+      "idx": 16,
+      "version": "6",
+      "when": 1791191766572,
+      "tag": "0016_milestones_project_default",
+      "breakpoints": true
+    },
+    {
+      "idx": 17,
+      "version": "6",
+      "when": 1791262161043,
+      "tag": "0017_events_raw_cli_session_id",
+      "breakpoints": true
     }
   ]
 }