@mean-weasel/lineage 0.1.4 → 0.1.6

package/dist/cli/lineage-dev.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli/lineageCli.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync3 } from "node:fs";
 import { homedir, platform } from "node:os";
-import { dirname as dirname3, join as join5, resolve as resolve3 } from "node:path";
+import { dirname as dirname3, join as join6, resolve as resolve4 } from "node:path";
 import { spawn } from "node:child_process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
@@ -40,12 +40,92 @@ var mimeByExt = {
   ".webp": "image/webp"
 };
 var localReviewExts = new Set(Object.keys(mimeByExt));
+var channelFromName = /\b(linkedin|meta|tiktok|youtube|x-twitter|x)\b/i;
+var campaignFromPath = /\b(20\d{2}-\d{2}-[a-z0-9-]+)\b/i;
+function localReviewRoot(repoRoot2) {
+  return join(repoRoot2, ".asset-scratch");
+}
 function contentTypeFor(file) {
   return mimeByExt[extname(file).toLowerCase()] || "application/octet-stream";
 }
 function fileSha256(file) {
   return createHash("sha256").update(readFileSync(file)).digest("hex");
 }
+function walkLocalReviewFiles(dir, files = []) {
+  if (!existsSync(dir)) return files;
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") return files;
+    throw error;
+  }
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "studio-uploads" || entry.name === "playwright-results" || entry.name === "lineage-demo") continue;
+    if (process.env.NODE_ENV !== "test" && /^vitest-/.test(entry.name)) continue;
+    const path = join(dir, entry.name);
+    if (entry.isDirectory()) walkLocalReviewFiles(path, files);
+    else if (entry.isFile() && localReviewExts.has(extname(entry.name).toLowerCase())) files.push(path);
+  }
+  return files;
+}
+function inferCampaign(relativePath) {
+  return campaignFromPath.exec(relativePath)?.[1] || "local-review";
+}
+function inferChannel(relativePath) {
+  const match = channelFromName.exec(relativePath);
+  if (!match) return "local";
+  return match[1].toLowerCase() === "x" ? "x-twitter" : match[1].toLowerCase();
+}
+function inferContentType(file) {
+  const mime = contentTypeFor(file);
+  if (mime.startsWith("image/gif")) return "gif";
+  if (mime.startsWith("image/")) return "image";
+  if (mime.startsWith("video/")) return "video";
+  return "other";
+}
+function listLocalReviewAssets(repoRoot2, project, catalog) {
+  const catalogChecksums = new Set(catalog.assets.map((asset) => asset.s3?.checksum_sha256).filter(Boolean));
+  const root = localReviewRoot(repoRoot2);
+  return walkLocalReviewFiles(root).flatMap((file) => {
+    try {
+      const stats = statSync(file);
+      const checksum = fileSha256(file);
+      const relativePath = relative(root, file);
+      return [{ checksum, file, relativePath, stats }];
+    } catch (error) {
+      if (error.code === "ENOENT") return [];
+      throw error;
+    }
+  }).filter((item) => !catalogChecksums.has(item.checksum)).map((item) => {
+    const fileSlug = basename(item.file, extname(item.file));
+    const channel = inferChannel(item.relativePath);
+    return {
+      asset_id: `local-${item.checksum.slice(0, 12)}`,
+      project,
+      product: project,
+      source: "local",
+      campaign: inferCampaign(item.relativePath),
+      channel,
+      audience: "local-review",
+      status: "planned",
+      content_type: inferContentType(item.file),
+      title: fileSlug.replace(/[-_]+/g, " "),
+      hook: item.relativePath,
+      cta: "Review before upload",
+      utm_content: fileSlug.replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "").toLowerCase() || "local_review",
+      notes: "Local pre-push asset. Review and refine before uploading to S3.",
+      local: {
+        relative_path: item.relativePath,
+        absolute_path: item.file,
+        size_bytes: item.stats.size,
+        content_type: contentTypeFor(item.file),
+        checksum_sha256: item.checksum,
+        updated_at: item.stats.mtime.toISOString()
+      }
+    };
+  });
+}
 
 // src/server/adapters/storage/s3StorageAdapter.ts
 function parseAssetIdFromS3Key(key) {
@@ -227,6 +307,7 @@ var defaultProduct = process.env.LINEAGE_DEFAULT_PRODUCT || defaultProject;
 var publicFallbackBucket = "lineage-demo-assets";
 var publicFallbackRegion = "us-east-1";
 var contentTypes = /* @__PURE__ */ new Set(["image", "video", "gif", "audio", "doc", "other"]);
+var baseChannels = ["linkedin", "meta", "tiktok", "x-twitter", "youtube"];
 var projectNamePattern = /^[a-z0-9][a-z0-9-]*$/;
 var LineageAssetError = class extends Error {
   constructor(message, status = 400) {
@@ -360,6 +441,9 @@ function defaultFallbackCatalog() {
     project: defaultProject
   }, defaultProject);
 }
+function isDefaultFallbackCatalog(catalog) {
+  return catalog.project === defaultProject && !existsSync3(catalogPath(defaultProject));
+}
 function loadCatalog(project = defaultProject) {
   const path = catalogPath(project);
   if (existsSync3(path)) {
@@ -425,6 +509,67 @@ var storageAdapter = createS3StorageAdapter({
   saveCatalog,
   supportedContentTypes: contentTypes
 });
+function uniqueSorted(values) {
+  return Array.from(new Set(values.filter(Boolean))).sort();
+}
+function facetsFor(assets) {
+  return {
+    audiences: uniqueSorted(assets.map((asset) => asset.audience)),
+    campaigns: uniqueSorted(assets.map((asset) => asset.campaign)),
+    channels: uniqueSorted([...baseChannels, ...assets.map((asset) => asset.channel)]),
+    contentTypes: uniqueSorted(assets.map((asset) => asset.content_type)),
+    placementStatuses: uniqueSorted(assets.flatMap((asset) => asset.placements?.map((placement) => placement.status) || [])),
+    statuses: uniqueSorted(assets.map((asset) => asset.status)),
+    totalSizeBytes: assets.reduce((sum, asset) => sum + (asset.s3?.size_bytes || 0), 0)
+  };
+}
+function filteredAssets(assets, options) {
+  const query = options.query?.trim().toLowerCase();
+  return assets.filter((asset) => {
+    if (options.status && options.status !== "all" && asset.status !== options.status) return false;
+    if (options.channel && options.channel !== "all" && asset.channel !== options.channel) return false;
+    if (options.type && options.type !== "all" && asset.content_type !== options.type) return false;
+    if (options.placementStatus === "not-posted" && asset.placements?.some((placement) => placement.status === "posted")) return false;
+    if (options.placementStatus && !["all", "not-posted"].includes(options.placementStatus) && !asset.placements?.some((placement) => placement.status === options.placementStatus)) return false;
+    if (options.campaign && options.campaign !== "all" && asset.campaign !== options.campaign) return false;
+    if (options.audience && options.audience !== "all" && asset.audience !== options.audience) return false;
+    if (!query) return true;
+    return [asset.asset_id, asset.title, asset.campaign, asset.channel, asset.audience, asset.hook, asset.cta].join(" ").toLowerCase().includes(query);
+  });
+}
+function listAssets(project = defaultProject, options = {}) {
+  const catalog = loadCatalog(project);
+  const pageSize = Math.min(Math.max(Number(options.pageSize || 10), 1), 100);
+  const page = Math.max(Number(options.page || 1), 1);
+  const localAssets = listLocalReviewAssets(repoRoot, catalog.project, catalog);
+  const source = options.source || "catalog";
+  const sourceAssets = source === "local" ? localAssets : source === "all" ? [...localAssets, ...catalog.assets] : catalog.assets;
+  const filtered = filteredAssets(sourceAssets, options);
+  const totalPages = Math.max(Math.ceil(filtered.length / pageSize), 1);
+  const safePage = Math.min(page, totalPages);
+  const start2 = (safePage - 1) * pageSize;
+  const pageAssets = filtered.slice(start2, start2 + pageSize);
+  let liveObjects = [];
+  let error;
+  if (options.includeLive && !isDefaultFallbackCatalog(catalog)) {
+    try {
+      liveObjects = storageAdapter.listLiveObjects(catalog);
+    } catch (err) {
+      error = err instanceof Error ? err.message : String(err);
+    }
+  }
+  return {
+    catalog: { project: catalog.project, product: catalog.product, default_bucket: catalog.default_bucket, default_region: catalog.default_region, asset_count: catalog.assets.length },
+    assets: pageAssets,
+    facets: facetsFor(catalog.assets),
+    pagination: { page: safePage, pageSize, total: filtered.length, totalPages },
+    liveObjects,
+    orphanObjects: liveObjects.filter((object) => !object.cataloged),
+    identity: options.includeLive && !isDefaultFallbackCatalog(catalog) ? storageAdapter.getIdentity() : void 0,
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    error
+  };
+}
 
 // src/server/assetLineageDb.ts
 var require2 = createRequire(import.meta.url);
@@ -481,6 +626,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')),
@@ -685,7 +868,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),
@@ -703,7 +886,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,
@@ -1204,6 +1387,9 @@ function validateAgentClaimForWrite(fields) {
   }
 }
 
+// src/server/assetLineage.ts
+import { join as join5 } from "node:path";
+
 // src/server/assetLineageSelection.ts
 function selectedRows(database, project, root) {
   return database.prepare(`
@@ -1297,6 +1483,37 @@ function activeLineageWorkspaceRoot(project) {
   }
 }
 
+// src/server/lineageClaimGuards.ts
+function channelOverlaps2(left, right) {
+  return !left || !right || left === right;
+}
+function hasActiveLineageWorkspaceClaim(project, targetId, channel) {
+  return listAgentClaims(project).claims.some((claim) => {
+    if (claim.project !== project || claim.status !== "active" || claim.derived_state === "expired") return false;
+    if (claim.scope_type === "lineage_workspace") return claim.target_id === targetId;
+    return claim.scope_type === "project_channel" && channelOverlaps2(channel, claim.channel);
+  });
+}
+function requireLineageWorkspaceClaimForWrite(fields) {
+  if (!fields.confirmWrite) return;
+  const targetId = lineageWorkspaceId(fields.project, fields.rootAssetId);
+  if (!fields.claimToken && !hasActiveLineageWorkspaceClaim(fields.project, targetId, fields.channel)) return;
+  const validation = validateAgentClaimForWrite({
+    channel: fields.channel,
+    claimToken: fields.claimToken,
+    confirmWrite: fields.confirmWrite,
+    dangerLevel: "enforce",
+    project: fields.project,
+    scopeType: "lineage_workspace",
+    targetId,
+    writeKind: fields.writeKind
+  });
+  if (!validation.ok) {
+    const status = validation.code === "claim_required" || validation.code === "claim_token_invalid" ? 401 : 409;
+    throw new AgentClaimError(validation.message, status, validation.code, validation.conflicts);
+  }
+}
+
 // src/server/assetLineage.ts
 var LineageError = class extends Error {
   constructor(message, status = 400) {
@@ -1305,6 +1522,70 @@ var LineageError = class extends Error {
   }
   status;
 };
+function collectAssets(project, source) {
+  const first = listAssets(project, { source, page: 1, pageSize: 100 });
+  const assets = [...first.assets];
+  for (let page = 2; page <= first.pagination.totalPages; page += 1) {
+    assets.push(...listAssets(project, { source, page, pageSize: 100 }).assets);
+  }
+  return assets;
+}
+function upsertProject(database, project) {
+  const timestamp = nowIso();
+  database.prepare(`
+    insert into projects (id, product, catalog_path, created_at, updated_at)
+    values (?, ?, ?, ?, ?)
+    on conflict(id) do update set product = excluded.product, updated_at = excluded.updated_at
+  `).run(project, project, join5(repoRoot, project, "assets", "catalog.json"), timestamp, timestamp);
+}
+function upsertAsset(database, project, asset) {
+  const timestamp = nowIso();
+  const source = asset.source === "local" ? "local" : "catalog";
+  database.prepare(`
+    insert into assets (
+      id, project_id, source, local_path, s3_key, checksum_sha256, media_type, title, status,
+      channel, campaign, audience, size_bytes, content_type, created_at, updated_at, last_seen_at
+    ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    on conflict(id) do update set
+      source = excluded.source, local_path = excluded.local_path, s3_key = excluded.s3_key,
+      checksum_sha256 = excluded.checksum_sha256, media_type = excluded.media_type,
+      title = excluded.title, status = excluded.status, channel = excluded.channel,
+      campaign = excluded.campaign, audience = excluded.audience, size_bytes = excluded.size_bytes,
+      content_type = excluded.content_type, updated_at = excluded.updated_at, last_seen_at = excluded.last_seen_at
+  `).run(
+    asset.asset_id,
+    project,
+    source,
+    asset.local?.relative_path || null,
+    asset.s3?.key || null,
+    asset.local?.checksum_sha256 || asset.s3?.checksum_sha256 || null,
+    asset.content_type,
+    asset.title,
+    asset.status,
+    asset.channel || null,
+    asset.campaign || null,
+    asset.audience || null,
+    asset.local?.size_bytes || asset.s3?.size_bytes || null,
+    asset.local?.content_type || asset.s3?.content_type || null,
+    timestamp,
+    timestamp,
+    timestamp
+  );
+  database.prepare(`
+    insert into asset_reviews (asset_id, review_state, updated_at)
+    values (?, 'unreviewed', ?)
+    on conflict(asset_id) do nothing
+  `).run(asset.asset_id, timestamp);
+}
+function indexLineageAssets(project = defaultProject) {
+  const database = lineageDb();
+  const catalog = collectAssets(project, "catalog");
+  const local = collectAssets(project, "local");
+  upsertProject(database, project);
+  for (const asset of [...catalog, ...local]) upsertAsset(database, project, asset);
+  database.close();
+  return { catalog: catalog.length, local: local.length, total: catalog.length + local.length, database: lineageDbPath() };
+}
 function requireAsset(database, project, assetId) {
   const row = database.prepare("select id from assets where project_id = ? and id = ?").get(project, assetId);
   if (!row) throw new LineageError(`Unknown indexed asset: ${assetId}`, 404);
@@ -1324,6 +1605,50 @@ function rootFor(database, project, assetId) {
   }
   return assetId;
 }
+function assertCanonicalRoot(database, project, root) {
+  requireAsset(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
+    where project_id = ? and root_asset_id = ? and status != 'archived'
+  `).get(project, assetId);
+  return row?.root_asset_id;
+}
+function nearestWorkspaceRoot(database, project, assetId) {
+  let current = assetId;
+  const seen = /* @__PURE__ */ new Set();
+  while (!seen.has(current)) {
+    seen.add(current);
+    const explicit = explicitWorkspaceRoot(database, project, current);
+    if (explicit) return explicit;
+    const parent = parentOf(database, project, current);
+    if (!parent) return current;
+    current = parent;
+  }
+  return assetId;
+}
+function assetChannel(database, project, assetId) {
+  const row = database.prepare("select channel from assets where project_id = ? and id = ?").get(project, assetId);
+  return row?.channel;
+}
+function lineageWriteClaimContext(database, project, assetId) {
+  return {
+    channel: assetChannel(database, project, assetId),
+    rootAssetId: nearestWorkspaceRoot(database, project, assetId)
+  };
+}
+function getLineageWriteClaimContext(project, assetId) {
+  const database = lineageDb();
+  try {
+    requireAsset(database, project, assetId);
+    return lineageWriteClaimContext(database, project, assetId);
+  } finally {
+    database.close();
+  }
+}
 function latestSelectedRoot(database, project) {
   const row = database.prepare("select root_asset_id from asset_selections where project_id = ? order by selected_at desc limit 1").get(project);
   return row?.root_asset_id;
@@ -1341,6 +1666,75 @@ 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);
+  requireAsset(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 assertAttemptAssetNotVisibleLineageNode(database, project, root, assetId) {
+  const visibleNodeIds = /* @__PURE__ */ new Set([
+    root,
+    ...descendants(database, project, root).flatMap((edge) => [edge.parent_asset_id, edge.child_asset_id])
+  ]);
+  if (visibleNodeIds.has(assetId)) throw new LineageError(`Attempt asset ${assetId} is already a visible lineage node in ${root}`, 400);
+}
 function canPreviewLocally(mediaType, localPath) {
   return Boolean(localPath && ["image", "video", "gif"].includes(mediaType));
 }
@@ -1354,6 +1748,20 @@ function linkLineageAssets(project, fields) {
   requireAsset(database, project, fields.parentAssetId);
   requireAsset(database, project, fields.childAssetId);
   if (fields.parentAssetId === fields.childAssetId) throw new LineageError("Lineage link cannot point to itself");
+  const claimContext = lineageWriteClaimContext(database, project, fields.parentAssetId);
+  try {
+    requireLineageWorkspaceClaimForWrite({
+      channel: claimContext.channel,
+      claimToken: fields.claimToken,
+      confirmWrite: fields.confirmWrite,
+      project,
+      rootAssetId: claimContext.rootAssetId,
+      writeKind: "lineage_link"
+    });
+  } catch (error) {
+    database.close();
+    throw error;
+  }
   const edge = {
     id: edgeId(project, fields.parentAssetId, fields.childAssetId),
     parent_asset_id: fields.parentAssetId,
@@ -1390,18 +1798,28 @@ function descendants(database, project, root) {
 function getLineageSnapshot(project, assetId) {
   const database = lineageDb();
   requireAsset(database, project, assetId);
-  const root = rootFor(database, project, assetId);
+  const root = explicitWorkspaceRoot(database, project, assetId) || rootFor(database, project, assetId);
   const edges = descendants(database, project, root);
   const ids = [.../* @__PURE__ */ new Set([root, ...edges.flatMap((edge) => [edge.parent_asset_id, edge.child_asset_id])])];
   const placeholders = ids.map(() => "?").join(",");
   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 (${placeholders})
   `).all(root, project, ...ids);
+  const attemptRows = ids.length > 0 ? database.prepare(`select * from asset_attempts where project_id = ? and node_asset_id in (${placeholders}) 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 (${placeholders}) 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));
@@ -1414,13 +1832,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)
     };
@@ -1507,6 +1931,160 @@ function getLineageNextAsset(project, rootAssetId) {
     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 recordLineageRerollAttempt(project, fields) {
+  const database = lineageDb();
+  try {
+    assertNodeInRoot(database, project, fields.rootAssetId, fields.nodeAssetId);
+    requireAsset(database, project, fields.assetId);
+    assertAttemptAssetNotVisibleLineageNode(database, project, fields.rootAssetId, fields.assetId);
+    const timestamp = nowIso();
+    const maxRow = database.prepare("select max(attempt_index) max_index from asset_attempts where project_id = ? and node_asset_id = ?").get(project, fields.nodeAssetId);
+    const attemptIndex = Number(maxRow.max_index || 1) + 1;
+    const attempt = {
+      id: `${project}:${fields.nodeAssetId}:attempt:${attemptIndex}`,
+      project_id: project,
+      node_asset_id: fields.nodeAssetId,
+      asset_id: fields.assetId,
+      attempt_index: attemptIndex,
+      source: "reroll",
+      prompt: fields.prompt,
+      generation_job_id: fields.generationJobId,
+      file_path: fields.filePath,
+      checksum_sha256: fields.checksumSha256,
+      created_at: timestamp,
+      promoted_at: timestamp,
+      is_current: true
+    };
+    if (!fields.confirmWrite) return { ok: true, dryRun: true, attempt };
+    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);
+      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', ?, ?, ?, ?, ?, ?, 1)
+      `).run(
+        attempt.id,
+        project,
+        fields.nodeAssetId,
+        fields.assetId,
+        attempt.attempt_index,
+        fields.prompt,
+        fields.generationJobId,
+        fields.filePath,
+        fields.checksumSha256,
+        timestamp,
+        timestamp
+      );
+      database.prepare(`
+        update asset_reroll_requests
+        set status = 'resolved', resolved_at = ?
+        where project_id = ? and root_asset_id = ? and node_asset_id = ? and status = 'pending'
+      `).run(timestamp, project, fields.rootAssetId, fields.nodeAssetId);
+      database.prepare(`
+        insert into asset_reviews (asset_id, review_state, reviewed_at, ignored_at, notes, updated_at)
+        values (?, 'unreviewed', ?, null, null, ?)
+        on conflict(asset_id) do update set
+          review_state = excluded.review_state, reviewed_at = excluded.reviewed_at,
+          ignored_at = excluded.ignored_at, updated_at = excluded.updated_at
+      `).run(fields.nodeAssetId, timestamp, timestamp);
+      database.exec("COMMIT");
+    } catch (error) {
+      database.exec("ROLLBACK");
+      throw error;
+    }
+    return { ok: true, attempt };
+  } 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();
+  }
+}
 
 // src/server/assetLineageHandoff.ts
 var publicPackageCommand = "npx @mean-weasel/lineage";
@@ -1566,14 +2144,15 @@ function linkSelectedLineageChild(project, fields) {
   const next = getLineageNextAsset(project, fields.rootAssetId);
   if (!next.next_asset) throw new LineageError("Cannot link child until a next base is selected or unambiguous");
   if (fields.confirmWrite) {
+    const claimContext = getLineageWriteClaimContext(project, next.next_asset.asset_id);
     const validation = validateAgentClaimForWrite({
-      channel: next.next_asset.channel,
+      channel: claimContext.channel,
       claimToken: fields.claimToken,
       confirmWrite: fields.confirmWrite,
       dangerLevel: "enforce",
       project,
       scopeType: "lineage_workspace",
-      targetId: lineageWorkspaceId(project, next.root_asset_id),
+      targetId: lineageWorkspaceId(project, claimContext.rootAssetId),
       writeKind: "link_child"
     });
     if (!validation.ok) throw new AgentClaimError(validation.message, validation.code === "claim_required" ? 401 : 403, validation.code, validation.conflicts);
@@ -1594,17 +2173,307 @@ function linkSelectedLineageChild(project, fields) {
   };
 }
 
+// src/server/generationReceipts.ts
+import { existsSync as existsSync4, realpathSync, statSync as statSync3 } from "node:fs";
+import { relative as relative2, resolve as resolve3 } from "node:path";
+import { randomUUID } from "node:crypto";
+var adapterVersion = "generation-receipts-v1";
+var provider = "codex-handoff";
+var GenerationReceiptError = class extends Error {
+  constructor(message, status = 400) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+function jobId() {
+  return `gen-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
+}
+function quote(value) {
+  return JSON.stringify(value);
+}
+function parseJson(value, fallback) {
+  if (!value) return fallback;
+  return JSON.parse(value);
+}
+function buildRerollHandoff(project, id, prompt, rootAssetId, target, request) {
+  const importCommand = `npx lineage reroll import --project ${quote(project)} --job-id ${quote(id)} --file <.asset-scratch-file> --confirm-write --json`;
+  return {
+    schema_version: "lineage.generation_handoff.v1",
+    provider,
+    project,
+    job_id: id,
+    prompt,
+    expected_output_count: 1,
+    lineage: {
+      root_asset_id: rootAssetId,
+      parent_asset_id: target.asset_id,
+      selection_strategy: "reroll_request",
+      parent_title: target.title,
+      parent_local_path: target.local_path,
+      parent_s3_key: target.s3_key
+    },
+    instructions: [
+      "Use Codex image generation outside Lineage server code.",
+      "Write the regenerated output file under .asset-scratch before import.",
+      "Do not call live provider APIs from the CLI or server.",
+      "Import exactly one output with reroll import, not link-child or generate image import.",
+      `Resolve re-roll request ${request.id}; do not create a visible lineage child edge.`
+    ],
+    import_command: importCommand,
+    guardrails: { live_generation: false, external_services: false, output_root: ".asset-scratch", confirm_write_required: true }
+  };
+}
+function receiptFrom(row) {
+  return {
+    id: String(row.id),
+    job_id: String(row.job_id),
+    receipt_type: row.receipt_type,
+    status: row.status,
+    command: String(row.command),
+    payload: parseJson(String(row.payload_json), null),
+    created_at: String(row.created_at)
+  };
+}
+function outputFrom(row) {
+  return {
+    id: String(row.id),
+    job_id: String(row.job_id),
+    project_id: String(row.project_id),
+    output_index: Number(row.output_index),
+    file_path: String(row.file_path),
+    checksum_sha256: String(row.checksum_sha256),
+    size_bytes: Number(row.size_bytes),
+    content_type: String(row.content_type),
+    imported_asset_id: String(row.imported_asset_id),
+    parent_asset_id: String(row.parent_asset_id),
+    imported_at: String(row.imported_at)
+  };
+}
+function loadGenerationJob(database, project, id) {
+  const row = database.prepare("select * from generation_jobs where project_id = ? and id = ?").get(project, id);
+  if (!row) throw new GenerationReceiptError(`Unknown generation job: ${id}`, 404);
+  const inputRows = database.prepare("select * from generation_job_inputs where job_id = ? order by position").all(id);
+  const inputs = inputRows.map((input) => ({
+    id: String(input.id),
+    job_id: String(input.job_id),
+    project_id: String(input.project_id),
+    asset_id: String(input.asset_id),
+    root_asset_id: String(input.root_asset_id),
+    role: input.role,
+    position: Number(input.position),
+    selection_strategy: String(input.selection_strategy),
+    selection_snapshot: parseJson(String(input.selection_snapshot_json), {})
+  }));
+  const outputs = database.prepare("select * from generation_job_outputs where job_id = ? order by output_index").all(id).map(outputFrom);
+  const receipts = database.prepare("select * from generation_job_receipts where job_id = ? order by created_at, id").all(id).map(receiptFrom);
+  return {
+    id: String(row.id),
+    project_id: String(row.project_id),
+    provider: row.provider,
+    adapter_version: String(row.adapter_version),
+    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),
+    status: row.status,
+    output_dir: typeof row.output_dir === "string" ? row.output_dir : void 0,
+    handoff: parseJson(String(row.handoff_json), {}),
+    created_at: String(row.created_at),
+    updated_at: String(row.updated_at),
+    imported_at: typeof row.imported_at === "string" ? row.imported_at : void 0,
+    inputs,
+    outputs,
+    receipts
+  };
+}
+function insertReceipt(database, id, type, command, payload) {
+  database.prepare(`
+    insert into generation_job_receipts (id, job_id, receipt_type, status, command, payload_json, created_at)
+    values (?, ?, ?, 'ok', ?, ?, ?)
+  `).run(`${id}:receipt:${type}:${Date.now()}`, id, type, command, JSON.stringify(payload), nowIso());
+}
+function planImageReroll(project = defaultProject, fields) {
+  const prompt = fields.prompt.trim();
+  if (!prompt) throw new GenerationReceiptError("Missing --prompt");
+  if (!fields.rootAssetId) throw new GenerationReceiptError("Missing --root");
+  if (!fields.targetAssetId) throw new GenerationReceiptError("Missing --target");
+  const snapshot = getLineageSnapshot(project, fields.rootAssetId);
+  const target = snapshot.nodes.find((node) => node.asset_id === fields.targetAssetId);
+  if (!target) throw new GenerationReceiptError(`Re-roll target is not in lineage: ${fields.targetAssetId}`, 404);
+  const request = listLineageRerollRequests(project, snapshot.root_asset_id).requests.find((item) => item.node_asset_id === fields.targetAssetId);
+  if (!request) throw new GenerationReceiptError(`No pending re-roll request for ${fields.targetAssetId}`);
+  const id = jobId();
+  const timestamp = nowIso();
+  const handoff = buildRerollHandoff(project, id, prompt, snapshot.root_asset_id, target, request);
+  const input = {
+    id: `${id}:input:0`,
+    job_id: id,
+    project_id: project,
+    asset_id: target.asset_id,
+    root_asset_id: snapshot.root_asset_id,
+    role: "reroll_target",
+    position: 0,
+    selection_strategy: "reroll_request",
+    selection_snapshot: {
+      project,
+      root_asset_id: snapshot.root_asset_id,
+      strategy: "selected",
+      selection_mode: "single",
+      recommended_action: "evolve_variations",
+      reason: "user_selected",
+      next_asset: target,
+      next_assets: [target],
+      latest: snapshot.latest,
+      selected: [target.asset_id],
+      selection: null,
+      selections: [],
+      candidates: snapshot.nodes,
+      warnings: ["Re-roll target: import output as an attempt, not a lineage child."],
+      fetchedAt: timestamp
+    }
+  };
+  const preview = {
+    id,
+    project_id: project,
+    provider,
+    adapter_version: adapterVersion,
+    source_mode: "lineage_reroll",
+    root_asset_id: snapshot.root_asset_id,
+    prompt,
+    expected_output_count: 1,
+    status: "planned",
+    output_dir: ".asset-scratch",
+    handoff,
+    created_at: timestamp,
+    updated_at: timestamp,
+    inputs: [input],
+    outputs: [],
+    receipts: [{
+      id: `${id}:receipt:plan:preview`,
+      job_id: id,
+      receipt_type: "plan",
+      status: "ok",
+      command: "reroll plan",
+      payload: { prompt, expected_output_count: 1, lineage: handoff.lineage, reroll_request_id: request.id },
+      created_at: timestamp
+    }]
+  };
+  if (fields.dryRun) return { ok: true, command: "generate image plan", project, dryRun: true, wouldWrite: true, job: preview };
+  const database = lineageDb();
+  try {
+    database.exec("BEGIN IMMEDIATE");
+    try {
+      database.prepare(`
+        insert into generation_jobs (
+          id, project_id, provider, adapter_version, source_mode, root_asset_id, prompt,
+          expected_output_count, status, output_dir, handoff_json, created_at, updated_at
+        ) values (?, ?, ?, ?, 'lineage_reroll', ?, ?, 1, 'planned', ?, ?, ?, ?)
+      `).run(id, project, provider, adapterVersion, snapshot.root_asset_id, prompt, ".asset-scratch", JSON.stringify(handoff), timestamp, timestamp);
+      database.prepare("insert into generation_job_inputs (id, job_id, project_id, asset_id, root_asset_id, role, position, selection_strategy, selection_snapshot_json) values (?, ?, ?, ?, ?, ?, ?, ?, ?)").run(input.id, id, project, input.asset_id, input.root_asset_id, input.role, input.position, input.selection_strategy, JSON.stringify(input.selection_snapshot));
+      insertReceipt(database, id, "plan", "reroll plan", preview.receipts[0].payload);
+      database.exec("COMMIT");
+    } catch (error) {
+      database.exec("ROLLBACK");
+      throw error;
+    }
+    return { ok: true, command: "generate image plan", project, job: loadGenerationJob(database, project, id) };
+  } finally {
+    database.close();
+  }
+}
+function isPathInside(child, parent) {
+  const rel = relative2(parent, child);
+  return Boolean(rel) && !rel.startsWith("..") && !rel.startsWith("/");
+}
+function resolveScratchFile(file) {
+  const scratchRoot = resolve3(repoRoot, ".asset-scratch");
+  const candidate = file.startsWith(".asset-scratch/") || resolve3(file).startsWith(scratchRoot) ? resolve3(repoRoot, file) : resolve3(scratchRoot, file);
+  if (!isPathInside(candidate, scratchRoot)) throw new GenerationReceiptError(`Import file must be under .asset-scratch: ${file}`);
+  if (!existsSync4(candidate)) throw new GenerationReceiptError(`Missing import file: ${file}`, 404);
+  const realScratchRoot = realpathSync(scratchRoot);
+  const realCandidate = realpathSync(candidate);
+  if (!isPathInside(realCandidate, realScratchRoot)) throw new GenerationReceiptError(`Import file must be under .asset-scratch: ${file}`);
+  const stats = statSync3(candidate);
+  if (!stats.isFile()) throw new GenerationReceiptError(`Import path is not a file: ${file}`);
+  const checksum = fileSha256(candidate);
+  return {
+    relativePath: relative2(scratchRoot, candidate),
+    checksum,
+    size: stats.size,
+    contentType: contentTypeFor(candidate),
+    assetId: `local-${checksum.slice(0, 12)}`
+  };
+}
+function importImageRerollOutput(project = defaultProject, fields) {
+  if (!fields.jobId) throw new GenerationReceiptError("Missing --job-id");
+  if (!fields.confirmWrite) throw new GenerationReceiptError("Generation import requires --confirm-write");
+  const database = lineageDb();
+  let job;
+  try {
+    job = loadGenerationJob(database, project, fields.jobId);
+  } finally {
+    database.close();
+  }
+  if (job.status !== "planned") throw new GenerationReceiptError(`Generation job is not importable from status: ${job.status}`);
+  if (job.source_mode !== "lineage_reroll") throw new GenerationReceiptError(`Generation job is not a re-roll job: ${job.source_mode}`);
+  const target = job.inputs.filter((input) => input.role === "reroll_target");
+  if (target.length !== 1) throw new GenerationReceiptError("Re-roll import requires exactly one reroll_target input");
+  const resolved = resolveScratchFile(fields.file);
+  indexLineageAssets(project);
+  const writeDb = lineageDb();
+  try {
+    const timestamp = nowIso();
+    writeDb.exec("BEGIN IMMEDIATE");
+    try {
+      const assetRow = writeDb.prepare("select id from assets where project_id = ? and id = ?").get(project, resolved.assetId);
+      if (!assetRow) throw new GenerationReceiptError(`Indexed local asset was not found: ${resolved.relativePath}`);
+      const outputId = `${fields.jobId}:output:0`;
+      writeDb.prepare(`insert into generation_job_outputs (
+        id, job_id, project_id, output_index, file_path, checksum_sha256, size_bytes, content_type, imported_asset_id, parent_asset_id, imported_at
+      ) values (?, ?, ?, 0, ?, ?, ?, ?, ?, ?, ?)`).run(outputId, fields.jobId, project, resolved.relativePath, resolved.checksum, resolved.size, resolved.contentType, resolved.assetId, target[0].asset_id, timestamp);
+      writeDb.prepare(`
+        update generation_jobs
+        set status = 'imported', imported_at = ?, updated_at = ?
+        where project_id = ? and id = ?
+      `).run(timestamp, timestamp, project, fields.jobId);
+      insertReceipt(writeDb, fields.jobId, "import", "reroll import", {
+        file: { output_index: 0, file_path: resolved.relativePath, imported_asset_id: resolved.assetId, parent_asset_id: target[0].asset_id },
+        reroll: { root_asset_id: job.root_asset_id, node_asset_id: target[0].asset_id }
+      });
+      writeDb.exec("COMMIT");
+    } catch (error) {
+      writeDb.exec("ROLLBACK");
+      throw error;
+    }
+    recordLineageRerollAttempt(project, {
+      rootAssetId: job.root_asset_id,
+      nodeAssetId: target[0].asset_id,
+      assetId: resolved.assetId,
+      prompt: job.prompt,
+      generationJobId: fields.jobId,
+      filePath: resolved.relativePath,
+      checksumSha256: resolved.checksum,
+      confirmWrite: true
+    });
+    const importedJob = loadGenerationJob(writeDb, project, fields.jobId);
+    return { ok: true, command: "generate image import", project, job: importedJob, imported: importedJob.outputs };
+  } finally {
+    writeDb.close();
+  }
+}
+
 // src/cli/lineageCli.ts
 var signalExitCodes = {
   SIGINT: 130,
   SIGTERM: 143
 };
 function packageRoot() {
-  return resolve3(dirname3(fileURLToPath2(import.meta.url)), "..", "..");
+  return resolve4(dirname3(fileURLToPath2(import.meta.url)), "..", "..");
 }
 function packageVersion() {
   try {
-    const packageInfo = JSON.parse(readFileSync3(join5(packageRoot(), "package.json"), "utf8"));
+    const packageInfo = JSON.parse(readFileSync3(join6(packageRoot(), "package.json"), "utf8"));
     return packageInfo.version || "0.0.0";
   } catch {
     return "0.0.0";
@@ -1612,9 +2481,9 @@ function packageVersion() {
 }
 function dataRoot(displayName) {
   if (process.env.LINEAGE_HOME) return process.env.LINEAGE_HOME;
-  if (platform() === "darwin") return join5(homedir(), "Library", "Application Support", displayName);
-  if (platform() === "win32") return join5(process.env.APPDATA || join5(homedir(), "AppData", "Roaming"), displayName);
-  return join5(process.env.XDG_DATA_HOME || join5(homedir(), ".local", "share"), displayName.toLowerCase().replace(/\s+/g, "-"));
+  if (platform() === "darwin") return join6(homedir(), "Library", "Application Support", displayName);
+  if (platform() === "win32") return join6(process.env.APPDATA || join6(homedir(), "AppData", "Roaming"), displayName);
+  return join6(process.env.XDG_DATA_HOME || join6(homedir(), ".local", "share"), displayName.toLowerCase().replace(/\s+/g, "-"));
 }
 function readOption(args, name) {
   const prefix = `${name}=`;
@@ -1632,7 +2501,7 @@ function resolveStartOptions(config, args) {
     throw new Error(`Invalid port: ${rawPort}`);
   }
   return {
-    dbPath: readOption(args, "--db") || process.env.LINEAGE_DB || join5(runtimeDir, `${config.binName}.sqlite`),
+    dbPath: readOption(args, "--db") || process.env.LINEAGE_DB || join6(runtimeDir, `${config.binName}.sqlite`),
     host: readOption(args, "--host") || process.env.HOST || config.defaultHost,
     json: args.includes("--json"),
     open: args.includes("--open"),
@@ -1648,7 +2517,13 @@ Usage:
   ${config.binName} brief [--project <project>] [--root <asset-id>] [--db <path>] [--json]
   ${config.binName} inspect --asset-id <asset-id> [--project <project>] [--db <path>] [--json]
   ${config.binName} link-child --root <asset-id> --child <asset-id> [--project <project>] [--claim-token <claim-id.secret>] [--confirm-write] [--db <path>] [--json]
+  ${config.binName} reroll list --root <asset-id> [--project <project>] [--db <path>] [--json]
+  ${config.binName} reroll mark --root <asset-id> --target <asset-id> [--notes <text>] [--requested-by agent|human|system] [--project <project>] [--confirm-write] [--db <path>] [--json]
+  ${config.binName} reroll cancel --root <asset-id> --target <asset-id> [--project <project>] [--confirm-write] [--db <path>] [--json]
+  ${config.binName} reroll plan --root <asset-id> --target <asset-id> --prompt <text> [--project <project>] [--db <path>] [--json]
+  ${config.binName} reroll import --job-id <job-id> --file <scratch-file> --confirm-write [--project <project>] [--db <path>] [--json]
   ${config.binName} agent claim --project <project> --scope <scope> --target <target-id> --agent-name <name> [--channel <channel>] [--ttl 20m] [--json]
+  ${config.binName} agent graph --root <asset-id> [--project <project>] [--db <path>] [--json]
   ${config.binName} agent status [--project <project>] [--json]
   ${config.binName} agent inspect --claim <claim-id> [--project <project>] [--json]
   ${config.binName} agent heartbeat --claim-token <claim-id.secret> [--json]
@@ -1710,8 +2585,63 @@ function runLineageDataCommand(command, args) {
       rootAssetId: options.rootAssetId || options.assetId
     });
   }
+  if (command === "reroll") {
+    const subcommand = positionalArgs(args)[0] || "";
+    if (subcommand === "list") {
+      if (!options.rootAssetId) throw new Error("lineage reroll list requires --root");
+      return listLineageRerollRequests(options.project, options.rootAssetId);
+    }
+    if (subcommand === "mark") {
+      const targetAssetId = readOption(args, "--target");
+      const requestedBy = rerollRequestedBy(readOption(args, "--requested-by") || "agent");
+      if (!options.rootAssetId) throw new Error("lineage reroll mark requires --root");
+      if (!targetAssetId) throw new Error("lineage reroll mark requires --target");
+      return markLineageRerollRequest(options.project, {
+        rootAssetId: options.rootAssetId,
+        nodeAssetId: targetAssetId,
+        notes: readOption(args, "--notes"),
+        requestedBy,
+        confirmWrite: options.confirmWrite
+      });
+    }
+    if (subcommand === "cancel") {
+      const targetAssetId = readOption(args, "--target");
+      if (!options.rootAssetId) throw new Error("lineage reroll cancel requires --root");
+      if (!targetAssetId) throw new Error("lineage reroll cancel requires --target");
+      return clearLineageRerollRequest(options.project, {
+        rootAssetId: options.rootAssetId,
+        nodeAssetId: targetAssetId,
+        confirmWrite: options.confirmWrite
+      });
+    }
+    if (subcommand === "plan") {
+      const targetAssetId = readOption(args, "--target");
+      const prompt = readOption(args, "--prompt");
+      if (!options.rootAssetId) throw new Error("lineage reroll plan requires --root");
+      if (!targetAssetId) throw new Error("lineage reroll plan requires --target");
+      if (!prompt) throw new Error("lineage reroll plan requires --prompt");
+      return planImageReroll(options.project, {
+        rootAssetId: options.rootAssetId,
+        targetAssetId,
+        prompt,
+        dryRun: args.includes("--dry-run")
+      });
+    }
+    if (subcommand === "import") {
+      const jobId2 = readOption(args, "--job-id");
+      const file = readOption(args, "--file");
+      if (!jobId2) throw new Error("lineage reroll import requires --job-id");
+      if (!file) throw new Error("lineage reroll import requires --file");
+      return importImageRerollOutput(options.project, { jobId: jobId2, file, confirmWrite: options.confirmWrite });
+    }
+    throw new Error(`Unknown reroll command: ${subcommand}`);
+  }
   throw new Error(`Unknown command: ${command}`);
 }
+function rerollRequestedBy(value) {
+  if (value === "agent" || value === "human" || value === "system") return value;
+  throw new Error(`Invalid re-roll requester: ${value}`);
+}
 function printDataResult(command, result, json) {
   if (json) {
     console.log(JSON.stringify(result, null, 2));
@@ -1740,6 +2670,24 @@ function printDataResult(command, result, json) {
     console.log(link.message || `${link.dryRun ? "Dry run: " : ""}Link ${link.edge?.child_asset_id || "child"} from ${link.edge?.parent_asset_id || "parent"}`);
     return;
   }
+  if (command === "reroll" && result && typeof result === "object") {
+    if ("requests" in result) {
+      const listed = result;
+      console.log(`${listed.requests.length} pending re-roll target(s)`);
+      for (const request of listed.requests) console.log(`${request.node_asset_id}${request.notes ? `: ${request.notes}` : ""}`);
+      return;
+    }
+    if ("job" in result) {
+      const planned = result;
+      console.log(planned.imported ? `Imported re-roll for ${planned.job?.id || "job"}` : `Planned re-roll ${planned.job?.id || "job"}`);
+      return;
+    }
+    if ("request" in result) {
+      const mutation = result;
+      console.log(`${mutation.dryRun ? "Dry run: " : ""}Re-roll ${mutation.request?.status || "request"} for ${mutation.request?.node_asset_id || "target"}`);
+      return;
+    }
+  }
   console.log(String(result));
 }
 function runLineageAgentCommand(command, args) {
@@ -1765,6 +2713,11 @@ function runLineageAgentCommand(command, args) {
     });
   }
   if (command === "status") return listAgentClaims(project);
+  if (command === "graph") {
+    const rootAssetId = readOption(args, "--root") || readOption(args, "--asset-id") || positionalArgs(args)[0];
+    if (!rootAssetId) throw new Error("lineage agent graph requires --root");
+    return getLineageSnapshot(project, rootAssetId);
+  }
   if (command === "inspect") {
     if (!claimId) throw new Error("lineage agent inspect requires --claim");
     return inspectAgentClaim(claimId, project);
@@ -1821,8 +2774,37 @@ function printAgentResult(command, result, json) {
     console.log(`${inspected.claim?.id || "claim"} ${inspected.claim?.status || "unknown"} ${inspected.claim?.target_id || ""}`.trim());
     return;
   }
+  if (command === "graph" && result && typeof result === "object" && "nodes" in result) {
+    console.log(formatAgentGraphDigest(result));
+    return;
+  }
   console.log(String(result));
 }
+function formatAgentGraphDigest(snapshot) {
+  const lines = [];
+  const titleFor = (assetId) => {
+    const node = snapshot.nodes.find((item) => item.asset_id === assetId);
+    return node?.title ? `${node.title} (${assetId})` : assetId;
+  };
+  const root = snapshot.nodes.find((node) => node.asset_id === snapshot.root_asset_id);
+  lines.push(`Lineage graph: ${root?.title || snapshot.root_asset_id}`);
+  lines.push(`Root: ${snapshot.root_asset_id}`);
+  lines.push(`Active: ${titleFor(snapshot.active_asset_id)}`);
+  lines.push(`Nodes: ${snapshot.nodes.length}  Edges: ${snapshot.edges.length}`);
+  const selected = snapshot.selected || [];
+  if (selected.length > 0) {
+    lines.push("Next variation:");
+    for (const assetId of selected) lines.push(`- ${titleFor(assetId)}`);
+  }
+  const latest = snapshot.latest || snapshot.nodes.filter((node) => node.is_latest).map((node) => node.asset_id);
+  if (latest.length > 0) {
+    lines.push("Latest leaves:");
+    for (const assetId of latest) lines.push(`- ${titleFor(assetId)}`);
+  }
+  lines.push("Edges:");
+  for (const edge of snapshot.edges) lines.push(`- ${titleFor(edge.parent_asset_id)} -> ${titleFor(edge.child_asset_id)}`);
+  return lines.join("\n");
+}
 function start(config, args) {
   let options;
   const json = args.includes("--json");
@@ -1834,8 +2816,8 @@ function start(config, args) {
     else console.error(`${config.binName}: ${message}`);
     process.exit(1);
   }
-  const serverPath = join5(packageRoot(), "dist", "server.js");
-  if (!existsSync4(serverPath)) {
+  const serverPath = join6(packageRoot(), "dist", "server.js");
+  if (!existsSync5(serverPath)) {
     const message = `Missing bundled server at ${serverPath}. Run npm run build before using ${config.binName} start from a source checkout.`;
     if (options.json) console.error(JSON.stringify({ ok: false, error: message }, null, 2));
     else console.error(`${config.binName}: ${message}`);
@@ -1889,7 +2871,7 @@ function runLineageCli(config, args = process.argv.slice(2)) {
     start(config, normalizedArgs.slice(1));
     return;
   }
-  if (command === "next" || command === "brief" || command === "inspect" || command === "link-child") {
+  if (command === "next" || command === "brief" || command === "inspect" || command === "link-child" || command === "reroll") {
     const commandArgs = normalizedArgs.slice(1);
     const json2 = commandArgs.includes("--json");
     try {