@mean-weasel/lineage 0.1.5 → 0.1.6

package/dist/server.js

@@ -339,6 +339,44 @@ function lineageDb() {
     );
     create index if not exists edges_parent on asset_edges(project_id, parent_asset_id);
     create index if not exists edges_child on asset_edges(project_id, child_asset_id);
+    create table if not exists asset_attempts (
+      id text primary key,
+      project_id text not null references projects(id),
+      node_asset_id text not null references assets(id),
+      asset_id text not null references assets(id),
+      attempt_index integer not null check (attempt_index > 0),
+      source text not null check (source in ('initial', 'generated_child', 'reroll')),
+      prompt text,
+      generation_job_id text,
+      file_path text,
+      checksum_sha256 text,
+      created_at text not null,
+      promoted_at text,
+      is_current integer not null check (is_current in (0, 1)),
+      unique(project_id, node_asset_id, attempt_index),
+      unique(project_id, node_asset_id, asset_id, source)
+    );
+    create unique index if not exists asset_attempts_one_current
+      on asset_attempts(project_id, node_asset_id)
+      where is_current = 1;
+    create index if not exists asset_attempts_node_created
+      on asset_attempts(project_id, node_asset_id, created_at);
+    create table if not exists asset_reroll_requests (
+      id text primary key,
+      project_id text not null references projects(id),
+      root_asset_id text not null references assets(id),
+      node_asset_id text not null references assets(id),
+      status text not null check (status in ('pending', 'resolved', 'cancelled')),
+      requested_by text not null check (requested_by in ('human', 'agent', 'system')),
+      notes text,
+      created_at text not null,
+      resolved_at text
+    );
+    create unique index if not exists asset_reroll_requests_one_pending
+      on asset_reroll_requests(project_id, root_asset_id, node_asset_id)
+      where status = 'pending';
+    create index if not exists asset_reroll_requests_root_status
+      on asset_reroll_requests(project_id, root_asset_id, status, created_at);
     create table if not exists asset_reviews (
       asset_id text primary key references assets(id),
       review_state text not null check (review_state in ('unreviewed', 'approved', 'needs_revision', 'rejected', 'ignored')),
@@ -543,7 +581,7 @@ function lineageDb() {
       project_id text not null references projects(id),
       provider text not null default 'codex-handoff',
       adapter_version text not null,
-      source_mode text not null check (source_mode in ('lineage_selection')),
+      source_mode text not null check (source_mode in ('lineage_selection', 'lineage_reroll')),
       root_asset_id text not null references assets(id),
       prompt text not null,
       expected_output_count integer not null check (expected_output_count > 0),
@@ -561,7 +599,7 @@ function lineageDb() {
       project_id text not null references projects(id),
       asset_id text not null references assets(id),
       root_asset_id text not null references assets(id),
-      role text not null check (role in ('lineage_next_base', 'reference')),
+      role text not null check (role in ('lineage_next_base', 'reference', 'reroll_target')),
       position integer not null,
       selection_strategy text not null,
       selection_snapshot_json text not null,
@@ -2085,6 +2123,11 @@ function rootFor(database, project, assetId) {
   }
   return assetId;
 }
+function assertCanonicalRoot(database, project, root) {
+  requireAsset2(database, project, root);
+  const canonicalRoot = rootFor(database, project, root);
+  if (canonicalRoot !== root) throw new LineageError(`Asset ${root} is not a lineage root`, 400);
+}
 function explicitWorkspaceRoot(database, project, assetId) {
   const row = database.prepare(`
     select root_asset_id from lineage_workspaces
@@ -2141,6 +2184,68 @@ function resolveRoot(database, project, rootAssetId) {
 function edgeId(project, parent, child) {
   return `${project}:${parent}:derived_from:${child}`;
 }
+function rerollRequestId(project, root, node, timestamp) {
+  return `${project}:${root}:reroll:${node}:${Date.parse(timestamp) || Date.now()}`;
+}
+function rowString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function rerollRequestFrom(row) {
+  return {
+    id: String(row.id),
+    project_id: String(row.project_id),
+    root_asset_id: String(row.root_asset_id),
+    node_asset_id: String(row.node_asset_id),
+    status: row.status,
+    requested_by: row.requested_by,
+    notes: rowString(row.notes),
+    created_at: String(row.created_at),
+    resolved_at: rowString(row.resolved_at)
+  };
+}
+function attemptFrom(row) {
+  return {
+    id: String(row.id),
+    project_id: String(row.project_id),
+    node_asset_id: String(row.node_asset_id),
+    asset_id: String(row.asset_id),
+    attempt_index: Number(row.attempt_index),
+    source: row.source,
+    prompt: rowString(row.prompt),
+    generation_job_id: rowString(row.generation_job_id),
+    file_path: rowString(row.file_path),
+    checksum_sha256: rowString(row.checksum_sha256),
+    created_at: String(row.created_at),
+    promoted_at: rowString(row.promoted_at),
+    is_current: Boolean(Number(row.is_current))
+  };
+}
+function implicitAttempt(row, isCurrent = true) {
+  const createdAt = row.asset_created_at || nowIso();
+  return {
+    id: `${row.project}:${row.asset_id}:attempt:implicit`,
+    project_id: row.project,
+    node_asset_id: row.asset_id,
+    asset_id: row.asset_id,
+    attempt_index: 1,
+    source: "initial",
+    file_path: row.local_path,
+    checksum_sha256: row.checksum_sha256,
+    created_at: createdAt,
+    promoted_at: createdAt,
+    is_current: isCurrent
+  };
+}
+function withImplicitAttempt(physicalAttempts, row) {
+  if (physicalAttempts.some((attempt) => attempt.source === "initial")) return physicalAttempts;
+  return [...physicalAttempts, implicitAttempt(row, !physicalAttempts.some((attempt) => attempt.is_current))];
+}
+function assertNodeInRoot(database, project, root, node) {
+  assertCanonicalRoot(database, project, root);
+  requireAsset2(database, project, node);
+  const nodeRoot = rootFor(database, project, node);
+  if (nodeRoot !== root) throw new LineageError(`Asset ${node} is not in lineage rooted at ${root}`);
+}
 function canPreviewLocally(mediaType, localPath) {
   return Boolean(localPath && ["image", "video", "gif"].includes(mediaType));
 }
@@ -2211,11 +2316,21 @@ function getLineageSnapshot(project, assetId) {
   const rows = database.prepare(`
     select a.id asset_id, a.project_id project, a.source, a.title, a.media_type, a.status, a.channel, a.campaign,
       a.local_path, a.s3_key, a.checksum_sha256, coalesce(r.review_state, 'unreviewed') review_state,
-      r.notes review_notes, l.x layout_x, l.y layout_y
+      r.notes review_notes, a.created_at asset_created_at, l.x layout_x, l.y layout_y
     from assets a left join asset_reviews r on r.asset_id = a.id
       left join asset_layouts l on l.project_id = a.project_id and l.root_asset_id = ? and l.asset_id = a.id
     where a.project_id = ? and a.id in (${placeholders2})
   `).all(root, project, ...ids);
+  const attemptRows = ids.length > 0 ? database.prepare(`select * from asset_attempts where project_id = ? and node_asset_id in (${placeholders2}) order by node_asset_id, attempt_index desc`).all(project, ...ids) : [];
+  const attemptsByNode = /* @__PURE__ */ new Map();
+  for (const attempt of attemptRows.map(attemptFrom)) {
+    attemptsByNode.set(attempt.node_asset_id, [...attemptsByNode.get(attempt.node_asset_id) || [], attempt]);
+  }
+  const rerollRows = ids.length > 0 ? database.prepare(`select * from asset_reroll_requests where project_id = ? and root_asset_id = ? and status = 'pending' and node_asset_id in (${placeholders2}) order by created_at`).all(project, root, ...ids) : [];
+  const rerollsByNode = new Map(rerollRows.map((row) => {
+    const request = rerollRequestFrom(row);
+    return [request.node_asset_id, request];
+  }));
   const selected = selectedRows(database, project, root);
   const childIds = new Set(edges.map((edge) => edge.parent_asset_id));
   const selectedIds = new Set(selected.map((row) => row.asset_id));
@@ -2228,13 +2343,19 @@ function getLineageSnapshot(project, assetId) {
   const selection = selections[0] || null;
   const nodes = rows.map((row) => {
     const position = typeof row.layout_x === "number" && typeof row.layout_y === "number" ? { x: row.layout_x, y: row.layout_y } : void 0;
-    const { layout_x: _layoutX, layout_y: _layoutY, ...node } = row;
+    const { asset_created_at: _assetCreatedAt, layout_x: _layoutX, layout_y: _layoutY, ...node } = row;
     const nodeSelection = selections.find((item) => item.asset_id === row.asset_id);
+    const attempts = withImplicitAttempt(attemptsByNode.get(row.asset_id) || [], row);
+    const currentAttempt = attempts.find((attempt) => attempt.is_current) || attempts[0];
+    const previewPath = currentAttempt?.file_path || row.local_path;
     return {
       ...node,
+      attempt_count: attempts.length,
+      current_attempt: currentAttempt,
       is_latest: !childIds.has(row.asset_id),
       position,
-      preview_url: canPreviewLocally(row.media_type, row.local_path) ? localPreviewUrl(project, row.local_path) : void 0,
+      preview_url: canPreviewLocally(row.media_type, previewPath) ? localPreviewUrl(project, previewPath) : void 0,
+      reroll_request: rerollsByNode.get(row.asset_id),
       selection_note: nodeSelection?.notes,
       user_selected: selectedIds.has(row.asset_id)
     };
@@ -2368,6 +2489,170 @@ function getLineageChildren(project, parentAssetId) {
     fetchedAt: nowIso()
   };
 }
+function listLineageRerollRequests(project, rootAssetId) {
+  const database = lineageDb();
+  try {
+    assertCanonicalRoot(database, project, rootAssetId);
+    const rows = database.prepare(`
+      select * from asset_reroll_requests
+      where project_id = ? and root_asset_id = ? and status = 'pending'
+      order by created_at, id
+    `).all(project, rootAssetId);
+    return { project, root_asset_id: rootAssetId, requests: rows.map(rerollRequestFrom), fetchedAt: nowIso() };
+  } finally {
+    database.close();
+  }
+}
+function getLineageAttempts(project, rootAssetId, nodeAssetId) {
+  const database = lineageDb();
+  try {
+    assertNodeInRoot(database, project, rootAssetId, nodeAssetId);
+    const rows = database.prepare(`
+      select * from asset_attempts
+      where project_id = ? and node_asset_id = ?
+      order by attempt_index desc, created_at desc
+    `).all(project, nodeAssetId);
+    const asset = database.prepare("select id asset_id, project_id project, local_path, checksum_sha256, created_at asset_created_at from assets where project_id = ? and id = ?").get(project, nodeAssetId);
+    return { project, root_asset_id: rootAssetId, node_asset_id: nodeAssetId, attempts: withImplicitAttempt(rows.map(attemptFrom), asset), fetchedAt: nowIso() };
+  } finally {
+    database.close();
+  }
+}
+function promoteLineageAttempt(project, fields) {
+  const database = lineageDb();
+  try {
+    assertNodeInRoot(database, project, fields.rootAssetId, fields.nodeAssetId);
+    const asset = database.prepare("select id asset_id, project_id project, local_path, checksum_sha256, created_at asset_created_at from assets where project_id = ? and id = ?").get(project, fields.nodeAssetId);
+    const rows = database.prepare(`
+      select * from asset_attempts
+      where project_id = ? and node_asset_id = ?
+      order by attempt_index desc, created_at desc
+    `).all(project, fields.nodeAssetId);
+    const attempts = withImplicitAttempt(rows.map(attemptFrom), asset);
+    const target = attempts.find((attempt2) => attempt2.id === fields.attemptId);
+    if (!target) throw new LineageError(`Attempt ${fields.attemptId} is not in ${fields.nodeAssetId}`, 404);
+    const timestamp = nowIso();
+    const promotedAttempt = { ...target, is_current: true, promoted_at: timestamp };
+    if (!fields.confirmWrite) {
+      return {
+        ok: true,
+        dryRun: true,
+        project,
+        root_asset_id: fields.rootAssetId,
+        node_asset_id: fields.nodeAssetId,
+        attempt: promotedAttempt,
+        attempts: attempts.map((attempt2) => ({ ...attempt2, is_current: attempt2.id === target.id, promoted_at: attempt2.id === target.id ? timestamp : attempt2.promoted_at })),
+        fetchedAt: timestamp
+      };
+    }
+    database.exec("BEGIN IMMEDIATE");
+    try {
+      database.prepare("update asset_attempts set is_current = 0 where project_id = ? and node_asset_id = ?").run(project, fields.nodeAssetId);
+      if (target.source !== "initial") {
+        const result = database.prepare(`
+          update asset_attempts
+          set is_current = 1, promoted_at = ?
+          where project_id = ? and node_asset_id = ? and id = ?
+        `).run(timestamp, project, fields.nodeAssetId, target.id);
+        if (result.changes !== 1) throw new LineageError(`Attempt ${fields.attemptId} is not in ${fields.nodeAssetId}`, 404);
+      }
+      database.exec("COMMIT");
+    } catch (error) {
+      database.exec("ROLLBACK");
+      throw error;
+    }
+    const refreshedRows = database.prepare(`
+      select * from asset_attempts
+      where project_id = ? and node_asset_id = ?
+      order by attempt_index desc, created_at desc
+    `).all(project, fields.nodeAssetId);
+    const refreshedAttempts = withImplicitAttempt(refreshedRows.map(attemptFrom), asset);
+    const attempt = refreshedAttempts.find((item) => item.id === target.id) || promotedAttempt;
+    return {
+      ok: true,
+      project,
+      root_asset_id: fields.rootAssetId,
+      node_asset_id: fields.nodeAssetId,
+      attempt,
+      attempts: refreshedAttempts,
+      fetchedAt: nowIso()
+    };
+  } finally {
+    database.close();
+  }
+}
+function markLineageRerollRequest(project, fields) {
+  const database = lineageDb();
+  try {
+    assertNodeInRoot(database, project, fields.rootAssetId, fields.nodeAssetId);
+    const existing = database.prepare(`
+      select * from asset_reroll_requests
+      where project_id = ? and root_asset_id = ? and node_asset_id = ? and status = 'pending'
+      order by created_at desc limit 1
+    `).get(project, fields.rootAssetId, fields.nodeAssetId);
+    const timestamp = nowIso();
+    const request = existing ? {
+      ...rerollRequestFrom(existing),
+      notes: fields.notes || rerollRequestFrom(existing).notes,
+      requested_by: fields.requestedBy || rerollRequestFrom(existing).requested_by
+    } : {
+      id: rerollRequestId(project, fields.rootAssetId, fields.nodeAssetId, timestamp),
+      project_id: project,
+      root_asset_id: fields.rootAssetId,
+      node_asset_id: fields.nodeAssetId,
+      status: "pending",
+      requested_by: fields.requestedBy || "human",
+      notes: fields.notes,
+      created_at: timestamp
+    };
+    if (!fields.confirmWrite) return { ok: true, dryRun: true, request };
+    if (existing) {
+      database.prepare(`
+        update asset_reroll_requests
+        set requested_by = ?, notes = ?
+        where id = ?
+      `).run(request.requested_by, request.notes || null, request.id);
+    } else {
+      database.prepare(`
+        insert into asset_reroll_requests (id, project_id, root_asset_id, node_asset_id, status, requested_by, notes, created_at, resolved_at)
+        values (?, ?, ?, ?, 'pending', ?, ?, ?, null)
+      `).run(request.id, project, fields.rootAssetId, fields.nodeAssetId, request.requested_by, request.notes || null, request.created_at);
+    }
+    database.prepare(`
+      insert into asset_reviews (asset_id, review_state, reviewed_at, ignored_at, notes, updated_at)
+      values (?, 'needs_revision', ?, null, ?, ?)
+      on conflict(asset_id) do update set
+        review_state = excluded.review_state, reviewed_at = excluded.reviewed_at,
+        ignored_at = excluded.ignored_at, notes = coalesce(excluded.notes, asset_reviews.notes), updated_at = excluded.updated_at
+    `).run(fields.nodeAssetId, timestamp, request.notes || null, timestamp);
+    return { ok: true, request: rerollRequestFrom(database.prepare("select * from asset_reroll_requests where id = ?").get(request.id)) };
+  } finally {
+    database.close();
+  }
+}
+function clearLineageRerollRequest(project, fields) {
+  const database = lineageDb();
+  try {
+    assertNodeInRoot(database, project, fields.rootAssetId, fields.nodeAssetId);
+    const existing = database.prepare(`
+      select * from asset_reroll_requests
+      where project_id = ? and root_asset_id = ? and node_asset_id = ? and status = 'pending'
+      order by created_at desc limit 1
+    `).get(project, fields.rootAssetId, fields.nodeAssetId);
+    if (!existing) throw new LineageError(`No pending re-roll request for ${fields.nodeAssetId}`, 404);
+    const timestamp = nowIso();
+    const request = { ...rerollRequestFrom(existing), status: "cancelled", resolved_at: timestamp };
+    if (!fields.confirmWrite) return { ok: true, dryRun: true, request };
+    database.prepare(`
+      update asset_reroll_requests
+      set status = 'cancelled', resolved_at = ?
+      where id = ?
+    `).run(timestamp, request.id);
+    return { ok: true, request };
+  } finally {
+    database.close();
+  }
+}
 function updateSelectedAsset(project, fields) {
   const database = lineageDb();
   const inputAssetIds = normalizeSelectionInput(fields);
@@ -4734,7 +5019,7 @@ function itemFromFile(file) {
   };
 }
 function demoMarkdownItems(kind) {
-  const root = join7(repoRoot, "demo-project", "channels");
+  const root = process.env.LINEAGE_CONTENT_SOURCE_ROOT || join7(repoRoot, "demo-project", "channels");
   if (!existsSync4(root)) return [];
   return walk(root).map(itemFromFile).filter((item) => Boolean(item)).filter((item) => kind === "all" || `${item.kind}s` === kind).sort((a, b) => a.sourcePath.localeCompare(b.sourcePath));
 }
@@ -5136,7 +5421,7 @@ function loadGenerationJob(database, project, id) {
     project_id: String(row.project_id),
     provider: row.provider,
     adapter_version: String(row.adapter_version),
-    source_mode: "lineage_selection",
+    source_mode: String(row.source_mode),
     root_asset_id: String(row.root_asset_id),
     prompt: String(row.prompt),
     expected_output_count: Number(row.expected_output_count),
@@ -5245,6 +5530,15 @@ function swissifierRelativePath(manifest, asset) {
 function swissifierFilePath(manifest, asset) {
   return join8(repoRoot, ".asset-scratch", swissifierRelativePath(manifest, asset));
 }
+function swissifierRerollRelativePath(manifest, attempt) {
+  return join8(manifest.media.target_dir, "reroll-attempts", attempt.file);
+}
+function swissifierRerollFilePath(manifest, attempt) {
+  return join8(repoRoot, ".asset-scratch", swissifierRerollRelativePath(manifest, attempt));
+}
+function swissifierRerollFixturePath(attempt) {
+  return join8(dirname3(swissifierManifestPath), "swissifier-rerolls", attempt.file);
+}
 function swissifierSourcePath(manifest, asset, sourceDir) {
   const direct = join8(sourceDir, asset.file);
   if (existsSync5(direct)) return direct;
@@ -5542,6 +5836,27 @@ function writeDemoFiles(project) {
   for (const asset of demoAssets) writeDemoFile(project, asset);
   return ids;
 }
+function swissifierRerollAsset(attempt) {
+  const source = swissifierRerollFixturePath(attempt);
+  if (!existsSync5(source)) throw new Error(`Missing Swissifier re-roll fixture media: ${attempt.file}`);
+  const body = readFileSync4(source);
+  if (body.length !== attempt.size_bytes) throw new Error(`Unexpected Swissifier re-roll fixture size for ${attempt.file}`);
+  const checksumSha256 = sha256Hex(body);
+  if (checksumSha256 !== attempt.checksum_sha256) throw new Error(`Checksum mismatch for Swissifier re-roll fixture: ${attempt.file}`);
+  return {
+    assetId: `local-${checksumSha256.slice(0, 12)}`,
+    checksumSha256,
+    sizeBytes: body.length
+  };
+}
+function writeSwissifierRerollFiles(manifest) {
+  for (const attempt of manifest.reroll_attempts || []) {
+    swissifierRerollAsset(attempt);
+    const target = swissifierRerollFilePath(manifest, attempt);
+    mkdirSync5(dirname3(target), { recursive: true });
+    copyFileSync2(swissifierRerollFixturePath(attempt), target);
+  }
+}
 function upsertDemoAssets(project, ids) {
   const database = lineageDb();
   const timestamp = nowIso();
@@ -5632,10 +5947,100 @@ function upsertSwissifierAssets(project, manifest) {
       );
       reviewStatement.run(asset.asset_id, timestamp);
     }
+    for (const attempt of manifest.reroll_attempts || []) {
+      const generated = swissifierRerollAsset(attempt);
+      assetStatement.run(
+        generated.assetId,
+        project,
+        swissifierRerollRelativePath(manifest, attempt),
+        generated.checksumSha256,
+        attempt.title,
+        "planned",
+        "local",
+        manifest.campaign,
+        manifest.audience,
+        generated.sizeBytes,
+        attempt.content_type,
+        timestamp,
+        timestamp,
+        timestamp
+      );
+      reviewStatement.run(generated.assetId, timestamp);
+    }
   } finally {
     database.close();
   }
-  return { catalog: 0, local: manifest.assets.length, total: manifest.assets.length };
+  const attemptCount = manifest.reroll_attempts?.length || 0;
+  return { catalog: 0, local: manifest.assets.length + attemptCount, total: manifest.assets.length + attemptCount };
+}
+function upsertSwissifierRerollAttempts(project, manifest) {
+  const attempts = manifest.reroll_attempts || [];
+  if (attempts.length === 0) return { total: 0 };
+  const database = lineageDb();
+  const timestamp = nowIso();
+  try {
+    database.exec("BEGIN IMMEDIATE");
+    try {
+      const nodes = new Set(attempts.map((attempt) => attempt.node_asset_id));
+      for (const nodeAssetId of nodes) {
+        database.prepare("update asset_attempts set is_current = 0 where project_id = ? and node_asset_id = ?").run(project, nodeAssetId);
+      }
+      const statement = database.prepare(`
+        insert into asset_attempts (
+          id, project_id, node_asset_id, asset_id, attempt_index, source, prompt, generation_job_id,
+          file_path, checksum_sha256, created_at, promoted_at, is_current
+        ) values (?, ?, ?, ?, ?, 'reroll', ?, ?, ?, ?, ?, ?, ?)
+        on conflict(id) do update set
+          asset_id = excluded.asset_id,
+          source = excluded.source,
+          prompt = excluded.prompt,
+          generation_job_id = excluded.generation_job_id,
+          file_path = excluded.file_path,
+          checksum_sha256 = excluded.checksum_sha256,
+          promoted_at = excluded.promoted_at,
+          is_current = excluded.is_current
+      `);
+      for (const attempt of attempts) {
+        const generated = swissifierRerollAsset(attempt);
+        statement.run(
+          `${project}:${attempt.node_asset_id}:attempt:${attempt.attempt_index}`,
+          project,
+          attempt.node_asset_id,
+          generated.assetId,
+          attempt.attempt_index,
+          attempt.prompt,
+          attempt.generation_job_id,
+          swissifierRerollRelativePath(manifest, attempt),
+          generated.checksumSha256,
+          timestamp,
+          timestamp,
+          attempt.current ? 1 : 0
+        );
+      }
+      for (const nodeAssetId of nodes) {
+        const currentCount = database.prepare("select count(*) count from asset_attempts where project_id = ? and node_asset_id = ? and is_current = 1").get(project, nodeAssetId);
+        if (currentCount.count === 0) {
+          database.prepare(`
+            update asset_attempts
+            set is_current = 1, promoted_at = ?
+            where id = (
+              select id from asset_attempts
+              where project_id = ? and node_asset_id = ?
+              order by attempt_index desc
+              limit 1
+            )
+          `).run(timestamp, project, nodeAssetId);
+        }
+      }
+      database.exec("COMMIT");
+    } catch (error) {
+      database.exec("ROLLBACK");
+      throw error;
+    }
+  } finally {
+    database.close();
+  }
+  return { total: attempts.length };
 }
 function seedDemoLineageWorkspace(project, fields) {
   const ids = fields.confirmWrite ? writeDemoFiles(project) : demoAssetIds();
@@ -5694,10 +6099,12 @@ function seedSwissifierRichDemoWorkspace(project, fields) {
       media_status: swissifierRichDemoMediaStatus(project)
     };
   }
+  writeSwissifierRerollFiles(manifest);
   const summary = upsertSwissifierAssets(project, manifest);
   for (const edge of manifest.edges) {
     linkLineageAssets(project, { parentAssetId: edge.parent, childAssetId: edge.child, confirmWrite: true });
   }
+  const reroll_attempts = upsertSwissifierRerollAttempts(project, manifest);
   updateSelectedAsset(project, {
     assetIds: manifest.selected_asset_ids,
     confirmWrite: true,
@@ -5725,6 +6132,7 @@ function seedSwissifierRichDemoWorkspace(project, fields) {
     media_status: swissifierRichDemoMediaStatus(project),
     root_asset_id: manifest.root_asset_id,
     selected_asset_ids: manifest.selected_asset_ids,
+    reroll_attempts,
     summary,
     workspace
   };
@@ -5931,6 +6339,36 @@ app.get(
   })
 );
 registerLineageWorkspaceRoutes(app, projectFrom, asyncRoute);
+app.get("/api/lineage/:rootAssetId/rerolls", asyncRoute((req, res) => {
+  res.json(listLineageRerollRequests(projectFrom(req), req.params.rootAssetId));
+}));
+app.post("/api/lineage/:rootAssetId/rerolls/:nodeAssetId", asyncRoute((req, res) => {
+  res.json(markLineageRerollRequest(projectFrom(req), {
+    rootAssetId: req.params.rootAssetId,
+    nodeAssetId: req.params.nodeAssetId,
+    notes: typeof req.body.notes === "string" ? req.body.notes : void 0,
+    requestedBy: req.body.requestedBy === "agent" || req.body.requestedBy === "system" ? req.body.requestedBy : "human",
+    confirmWrite: req.body.confirmWrite === true
+  }));
+}));
+app.post("/api/lineage/:rootAssetId/rerolls/:nodeAssetId/cancel", asyncRoute((req, res) => {
+  res.json(clearLineageRerollRequest(projectFrom(req), {
+    rootAssetId: req.params.rootAssetId,
+    nodeAssetId: req.params.nodeAssetId,
+    confirmWrite: req.body.confirmWrite === true
+  }));
+}));
+app.get("/api/lineage/:rootAssetId/attempts/:nodeAssetId", asyncRoute((req, res) => {
+  res.json(getLineageAttempts(projectFrom(req), req.params.rootAssetId, req.params.nodeAssetId));
+}));
+app.post("/api/lineage/:rootAssetId/attempts/:nodeAssetId/promote", asyncRoute((req, res) => {
+  res.json(promoteLineageAttempt(projectFrom(req), {
+    rootAssetId: req.params.rootAssetId,
+    nodeAssetId: req.params.nodeAssetId,
+    attemptId: String(req.body.attemptId || ""),
+    confirmWrite: req.body.confirmWrite === true
+  }));
+}));
 app.get("/api/lineage/:assetId", asyncRoute((req, res) => {
   res.json(getLineageSnapshot(projectFrom(req), req.params.assetId));
 }));