@mean-weasel/lineage 0.1.5 → 0.1.7

package/dist/cli/lineage.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);
@@ -470,6 +615,10 @@ function lineageDb() {
     create index if not exists assets_project_source_seen on assets(project_id, source, last_seen_at);
     create index if not exists assets_project_checksum on assets(project_id, checksum_sha256);
     create index if not exists assets_project_channel_campaign on assets(project_id, channel, campaign);
+    create table if not exists lineage_schema_migrations (
+      key text primary key,
+      applied_at text not null
+    );
     create table if not exists asset_edges (
       id text primary key,
       project_id text not null references projects(id),
@@ -481,6 +630,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 +872,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 +890,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,
@@ -737,12 +924,49 @@ function lineageDb() {
     );
     create index if not exists generation_job_receipts_job on generation_job_receipts(job_id, created_at);
     create table if not exists adapter_settings (project_id text not null references projects(id), adapter_type text not null check (adapter_type in ('cloud', 'scheduler', 'image_generator')), provider text not null, enabled integer not null check (enabled in (0, 1)), secret_ref text, safe_config_json text not null, created_at text not null, updated_at text not null, primary key(project_id, adapter_type, provider)); create index if not exists adapter_settings_project_type on adapter_settings(project_id, adapter_type);
+    create table if not exists lineage_tasks (
+      id text primary key,
+      project_id text not null references projects(id),
+      root_asset_id text not null references assets(id),
+      target_asset_id text not null references assets(id),
+      task_type text not null check (task_type in ('iterate', 'reroll')),
+      status text not null check (status in ('pending', 'claimed', 'in_progress', 'resolved', 'cancelled')),
+      instructions text,
+      created_by text not null check (created_by in ('human', 'agent', 'system')),
+      created_at text not null,
+      updated_at text not null,
+      claimed_at text,
+      started_at text,
+      resolved_at text,
+      cancelled_at text,
+      resolved_generation_job_id text,
+      resolved_asset_id text references assets(id),
+      metadata_json text
+    );
+    create unique index if not exists lineage_tasks_one_open
+      on lineage_tasks(project_id, root_asset_id, target_asset_id, task_type)
+      where status in ('pending', 'claimed', 'in_progress');
+    create index if not exists lineage_tasks_root_status
+      on lineage_tasks(project_id, root_asset_id, status, updated_at);
+    create index if not exists lineage_tasks_target
+      on lineage_tasks(project_id, root_asset_id, target_asset_id, task_type, status);
+    create table if not exists lineage_task_events (
+      id text primary key,
+      task_id text not null references lineage_tasks(id) on delete cascade,
+      event_type text not null,
+      actor text,
+      message text,
+      created_at text not null,
+      metadata_json text
+    );
+    create index if not exists lineage_task_events_task_created
+      on lineage_task_events(task_id, created_at);
     create table if not exists agent_claims (
       id text primary key,
       token_hash text not null,
       project_id text not null references projects(id),
       channel text,
-      scope_type text not null check (scope_type in ('lineage_workspace', 'content_post', 'content_queue_lane', 'selection_set', 'project_channel')),
+      scope_type text not null check (scope_type in ('lineage_workspace', 'lineage_task', 'content_post', 'content_queue_lane', 'selection_set', 'project_channel')),
       target_id text not null,
       target_title text,
       agent_id text,
@@ -776,13 +1000,76 @@ function lineageDb() {
   migrateAssetSelections(database);
   dropLegacyAssetSelectionRootUnique(database);
   ensureColumn(database, "asset_selections", "notes", "text");
+  backfillLineageTasks(database);
   ensureColumn(database, "asset_ledger_records", "first_seen_at", "text");
   ensureColumn(database, "asset_ledger_records", "indexed_by_run_id", "text");
   ensureColumn(database, "asset_ledger_sources", "first_seen_at", "text");
   ensureColumn(database, "asset_ledger_sources", "indexed_by_run_id", "text");
   ensureReviewStateValues(database);
+  ensureAgentClaimScopeValues(database);
+  ensureGenerationReceiptCheckValues(database);
   return database;
 }
+function backfillLineageTasks(database) {
+  database.exec(`
+    create table if not exists lineage_schema_migrations (
+      key text primary key,
+      applied_at text not null
+    )
+  `);
+  const marker = database.prepare("select key from lineage_schema_migrations where key = 'lineage_tasks_backfilled_v1'").get();
+  if (marker) return;
+  database.exec("BEGIN IMMEDIATE");
+  try {
+    database.exec(`
+      insert or ignore into lineage_tasks (
+        id, project_id, root_asset_id, target_asset_id, task_type, status, instructions,
+        created_by, created_at, updated_at, metadata_json
+      )
+      select
+        s.project_id || ':' || s.root_asset_id || ':lineage-task:iterate:' || s.asset_id,
+        s.project_id,
+        s.root_asset_id,
+        s.asset_id,
+        'iterate',
+        'pending',
+        s.notes,
+        'human',
+        s.selected_at,
+        s.selected_at,
+        null
+      from asset_selections s;
+
+      insert or ignore into lineage_tasks (
+        id, project_id, root_asset_id, target_asset_id, task_type, status, instructions,
+        created_by, created_at, updated_at, metadata_json
+      )
+      select
+        r.project_id || ':' || r.root_asset_id || ':lineage-task:reroll:' || r.node_asset_id,
+        r.project_id,
+        r.root_asset_id,
+        r.node_asset_id,
+        'reroll',
+        'pending',
+        r.notes,
+        r.requested_by,
+        r.created_at,
+        r.created_at,
+        null
+      from asset_reroll_requests r
+      where r.status = 'pending';
+    `);
+    database.prepare(`
+      insert into lineage_schema_migrations (key, applied_at)
+      values ('lineage_tasks_backfilled_v1', ?)
+      on conflict(key) do nothing
+    `).run(nowIso());
+    database.exec("COMMIT");
+  } catch (error) {
+    database.exec("ROLLBACK");
+    throw error;
+  }
+}
 function ensureColumn(database, table, column, definition) {
   const rows = database.prepare(`pragma table_info(${table})`).all();
   if (!rows.some((row) => row.name === column)) database.exec(`alter table ${table} add column ${column} ${definition}`);
@@ -846,12 +1133,138 @@ function ensureReviewStateValues(database) {
     drop table asset_reviews_old;
   `);
 }
+function ensureAgentClaimScopeValues(database) {
+  const createSql = database.prepare("select sql from sqlite_master where type = 'table' and name = 'agent_claims'").get();
+  if (createSql?.sql?.includes("'lineage_task'")) return;
+  database.exec("PRAGMA foreign_keys = OFF; PRAGMA legacy_alter_table = ON; BEGIN IMMEDIATE");
+  try {
+    database.exec(`
+      alter table agent_claims rename to agent_claims_old;
+      create table agent_claims (
+        id text primary key,
+        token_hash text not null,
+        project_id text not null references projects(id),
+        channel text,
+        scope_type text not null check (scope_type in ('lineage_workspace', 'lineage_task', 'content_post', 'content_queue_lane', 'selection_set', 'project_channel')),
+        target_id text not null,
+        target_title text,
+        agent_id text,
+        agent_name text not null,
+        agent_kind text not null,
+        thread_id text,
+        status text not null check (status in ('active', 'expired', 'released', 'revoked', 'transferred')),
+        created_at text not null,
+        heartbeat_at text not null,
+        expires_at text not null,
+        released_at text,
+        revoked_at text,
+        revoked_by text,
+        override_reason text,
+        metadata_json text
+      );
+      insert into agent_claims
+      select * from agent_claims_old;
+      drop table agent_claims_old;
+      create unique index if not exists agent_claims_token_hash on agent_claims(token_hash);
+      create index if not exists agent_claims_project_status on agent_claims(project_id, status, heartbeat_at);
+      create index if not exists agent_claims_target on agent_claims(project_id, channel, scope_type, target_id, status);
+    `);
+    const violations = database.prepare("pragma foreign_key_check").all();
+    if (violations.length > 0) throw new Error(`Agent claim scope migration failed foreign key check: ${JSON.stringify(violations)}`);
+    database.exec("COMMIT");
+  } catch (error) {
+    database.exec("ROLLBACK");
+    throw error;
+  } finally {
+    database.exec("PRAGMA legacy_alter_table = OFF; PRAGMA foreign_keys = ON");
+  }
+}
+function tableCreateSql(database, table) {
+  const row = database.prepare("select sql from sqlite_master where type = 'table' and name = ?").get(table);
+  return row?.sql || "";
+}
+function ensureGenerationReceiptCheckValues(database) {
+  const jobsSql = tableCreateSql(database, "generation_jobs");
+  const inputsSql = tableCreateSql(database, "generation_job_inputs");
+  const needsJobsMigration = Boolean(jobsSql && !jobsSql.includes("'lineage_reroll'"));
+  const needsInputsMigration = Boolean(inputsSql && !inputsSql.includes("'reroll_target'"));
+  if (!needsJobsMigration && !needsInputsMigration) return;
+  database.exec("PRAGMA foreign_keys = OFF; PRAGMA legacy_alter_table = ON; BEGIN IMMEDIATE");
+  try {
+    if (needsJobsMigration) migrateGenerationJobsCheck(database);
+    if (needsInputsMigration) migrateGenerationJobInputsCheck(database);
+    const violations = database.prepare("pragma foreign_key_check").all();
+    if (violations.length > 0) throw new Error(`Generation receipt migration failed foreign key check: ${JSON.stringify(violations)}`);
+    database.exec("COMMIT");
+  } catch (error) {
+    database.exec("ROLLBACK");
+    throw error;
+  } finally {
+    database.exec("PRAGMA legacy_alter_table = OFF; PRAGMA foreign_keys = ON");
+  }
+}
+function migrateGenerationJobsCheck(database) {
+  database.exec(`
+    alter table generation_jobs rename to generation_jobs_legacy_check;
+    create table generation_jobs (
+      id text primary key,
+      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', '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),
+      status text not null check (status in ('planned', 'imported', 'failed', 'cancelled')),
+      output_dir text,
+      handoff_json text,
+      created_at text not null,
+      updated_at text not null,
+      imported_at text
+    );
+    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, imported_at
+    )
+    select
+      id, project_id, provider, adapter_version, source_mode, root_asset_id, prompt,
+      expected_output_count, status, output_dir, handoff_json, created_at, updated_at, imported_at
+    from generation_jobs_legacy_check;
+    drop table generation_jobs_legacy_check;
+    create index if not exists generation_jobs_project_created on generation_jobs(project_id, created_at);
+  `);
+}
+function migrateGenerationJobInputsCheck(database) {
+  database.exec(`
+    alter table generation_job_inputs rename to generation_job_inputs_legacy_check;
+    create table generation_job_inputs (
+      id text primary key,
+      job_id text not null references generation_jobs(id) on delete cascade,
+      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', 'reroll_target')),
+      position integer not null,
+      selection_strategy text not null,
+      selection_snapshot_json text not null,
+      unique(job_id, asset_id, role)
+    );
+    insert into generation_job_inputs (
+      id, job_id, project_id, asset_id, root_asset_id, role, position, selection_strategy, selection_snapshot_json
+    )
+    select
+      id, job_id, project_id, asset_id, root_asset_id, role, position, selection_strategy, selection_snapshot_json
+    from generation_job_inputs_legacy_check;
+    drop table generation_job_inputs_legacy_check;
+    create index if not exists generation_job_inputs_job on generation_job_inputs(job_id, position);
+  `);
+}
 
 // src/server/agentClaims.ts
 var defaultTtlSeconds = 20 * 60;
 var idleAfterSeconds = 5 * 60;
 var staleAfterSeconds = 15 * 60;
-var scopes = /* @__PURE__ */ new Set(["lineage_workspace", "content_post", "content_queue_lane", "selection_set", "project_channel"]);
+var scopes = /* @__PURE__ */ new Set(["lineage_workspace", "lineage_task", "content_post", "content_queue_lane", "selection_set", "project_channel"]);
 var claimTokenPattern = /claim_[a-z0-9_-]+\.[A-Za-z0-9_-]+/g;
 var AgentClaimError = class extends Error {
   constructor(message, status = 400, code = "agent_claim_error", conflicts = []) {
@@ -1156,6 +1569,19 @@ function revokeAgentClaim(project, claimId, fields) {
     database.close();
   }
 }
+function revokeAgentClaimInDatabase(database, project, claimId, fields) {
+  expireActiveClaims(database);
+  const claim = findClaimById(database, claimId, project);
+  if (!claim) throw new AgentClaimError(`Unknown agent claim: ${claimId}`, 404, "claim_not_found");
+  if (claim.status !== "active") return claim;
+  const timestamp = nowIso();
+  database.prepare(`
+    update agent_claims set status = 'revoked', revoked_at = ?, revoked_by = ?, override_reason = ?
+    where id = ? and status = 'active'
+  `).run(timestamp, fields.actor || "human", fields.reason || null, claim.id);
+  recordEvent(database, claim.id, "revoked", fields.actor || "human", fields.reason);
+  return findClaimById(database, claim.id, project);
+}
 function transferAgentClaim(project, claimId, fields) {
   if (!fields.confirmWrite) throw new AgentClaimError("Transferring an agent claim requires confirmWrite=true.", 400, "confirm_write_required");
   const toAgentName = fields.toAgentName.trim();
@@ -1173,6 +1599,19 @@ function transferAgentClaim(project, claimId, fields) {
     database.close();
   }
 }
+function recordAgentClaimWriteAllowed(claim, fields) {
+  const database = lineageDb();
+  try {
+    recordEvent(database, claim.id, "write_allowed", claim.agent_name, `${fields.writeKind} allowed.`, {
+      danger_level: fields.dangerLevel,
+      target_id: fields.targetId,
+      write_kind: fields.writeKind
+    });
+    return { ok: true };
+  } finally {
+    database.close();
+  }
+}
 function validateAgentClaimForWrite(fields) {
   if (fields.dangerLevel === "danger" && !fields.confirmWrite) {
     return denied("human_confirmation_required", "Dangerous write requires explicit human confirmation.");
@@ -1193,17 +1632,22 @@ function validateAgentClaimForWrite(fields) {
     if (!scopeAllowsWrite(claim, fields.scopeType, fields.targetId, fields.writeKind)) {
       return denied("claim_scope_mismatch", `Claim does not cover ${fields.scopeType} ${fields.targetId}.`, [claim]);
     }
-    recordEvent(database, claim.id, "write_allowed", claim.agent_name, `${fields.writeKind} allowed.`, {
-      danger_level: fields.dangerLevel,
-      target_id: fields.targetId,
-      write_kind: fields.writeKind
-    });
+    if (fields.recordEvent !== false) {
+      recordEvent(database, claim.id, "write_allowed", claim.agent_name, `${fields.writeKind} allowed.`, {
+        danger_level: fields.dangerLevel,
+        target_id: fields.targetId,
+        write_kind: fields.writeKind
+      });
+    }
     return { ok: true, claim, warnings: [] };
   } finally {
     database.close();
   }
 }
 
+// src/server/assetLineage.ts
+import { join as join5 } from "node:path";
+
 // src/server/assetLineageSelection.ts
 function selectedRows(database, project, root) {
   return database.prepare(`
@@ -1214,6 +1658,507 @@ function selectedRows(database, project, root) {
   `).all(project, root);
 }
 
+// src/server/assetLineageTasks.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+var LineageTaskError = class extends Error {
+  constructor(message, status = 400) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+var activeStatuses = ["pending", "claimed", "in_progress"];
+var taskTypes = /* @__PURE__ */ new Set(["iterate", "reroll"]);
+var taskStatuses = /* @__PURE__ */ new Set(["pending", "claimed", "in_progress", "resolved", "cancelled"]);
+function taskIdFor(project, rootAssetId, targetAssetId, taskType) {
+  return `${project}:${rootAssetId}:lineage-task:${taskType}:${targetAssetId}`;
+}
+function randomId2(prefix) {
+  return `${prefix}_${Date.now().toString(36)}_${randomBytes2(6).toString("base64url").toLowerCase()}`;
+}
+function metadataJson2(metadata) {
+  return metadata ? JSON.stringify(metadata) : null;
+}
+function metadataWithoutClaim(metadata) {
+  if (!metadata) return void 0;
+  const next = { ...metadata };
+  delete next.claim_id;
+  return Object.keys(next).length > 0 ? next : void 0;
+}
+function parseMetadata2(value) {
+  if (typeof value !== "string" || !value) return void 0;
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function normalizeProject(project) {
+  const trimmed = project.trim();
+  if (!trimmed) throw new LineageTaskError("Lineage task requires project");
+  return trimmed;
+}
+function normalizeTaskType(taskType) {
+  if (!taskTypes.has(taskType)) throw new LineageTaskError(`Unsupported lineage task type: ${taskType}`);
+  return taskType;
+}
+function normalizeStatus(status) {
+  if (!taskStatuses.has(status)) throw new LineageTaskError(`Unsupported lineage task status: ${status}`);
+  return status;
+}
+function normalizeActor(actor, label) {
+  const trimmed = actor.trim();
+  if (!trimmed) throw new LineageTaskError(`${label} is required`);
+  return trimmed;
+}
+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 LineageTaskError(`Unknown indexed asset: ${assetId}`, 404);
+}
+function taskFromRow(row) {
+  const metadata = parseMetadata2(row.metadata_json);
+  const claimId = typeof metadata?.claim_id === "string" ? metadata.claim_id : void 0;
+  return {
+    id: String(row.id),
+    project_id: String(row.project_id),
+    root_asset_id: String(row.root_asset_id),
+    target_asset_id: String(row.target_asset_id),
+    task_type: String(row.task_type),
+    status: String(row.status),
+    instructions: typeof row.instructions === "string" ? row.instructions : void 0,
+    created_by: String(row.created_by),
+    created_at: String(row.created_at),
+    updated_at: String(row.updated_at),
+    claimed_at: typeof row.claimed_at === "string" ? row.claimed_at : void 0,
+    started_at: typeof row.started_at === "string" ? row.started_at : void 0,
+    resolved_at: typeof row.resolved_at === "string" ? row.resolved_at : void 0,
+    cancelled_at: typeof row.cancelled_at === "string" ? row.cancelled_at : void 0,
+    resolved_generation_job_id: typeof row.resolved_generation_job_id === "string" ? row.resolved_generation_job_id : void 0,
+    resolved_asset_id: typeof row.resolved_asset_id === "string" ? row.resolved_asset_id : void 0,
+    claimed_by_claim_id: claimId,
+    metadata
+  };
+}
+function eventFromRow(row) {
+  return {
+    id: String(row.id),
+    task_id: String(row.task_id),
+    event_type: String(row.event_type),
+    actor: typeof row.actor === "string" ? row.actor : void 0,
+    message: typeof row.message === "string" ? row.message : void 0,
+    created_at: String(row.created_at),
+    metadata: parseMetadata2(row.metadata_json)
+  };
+}
+function findTask(database, project, taskId) {
+  const row = database.prepare("select * from lineage_tasks where project_id = ? and id = ?").get(project, taskId);
+  return row ? taskFromRow(row) : null;
+}
+function requireTask(database, project, taskId) {
+  const task = findTask(database, project, taskId);
+  if (!task) throw new LineageTaskError(`Unknown lineage task: ${taskId}`, 404);
+  return task;
+}
+function taskEvents(database, taskId) {
+  const rows = database.prepare("select * from lineage_task_events where task_id = ? order by created_at, rowid").all(taskId);
+  return rows.map(eventFromRow);
+}
+function recordEvent2(database, taskId, eventType, actor, message, metadata) {
+  database.prepare(`
+    insert into lineage_task_events (id, task_id, event_type, actor, message, created_at, metadata_json)
+    values (?, ?, ?, ?, ?, ?, ?)
+  `).run(randomId2("lineage_task_event"), taskId, eventType, actor || null, message || null, nowIso(), metadataJson2(metadata));
+}
+function taskWithEvents(database, project, taskId) {
+  return { project, ok: true, task: requireTask(database, project, taskId), events: taskEvents(database, taskId) };
+}
+function assertChanged(result, message) {
+  if (Number(result.changes) !== 1) throw new LineageTaskError(message, 409);
+}
+function transaction(database, callback) {
+  database.exec("BEGIN IMMEDIATE");
+  try {
+    const value = callback();
+    database.exec("COMMIT");
+    return value;
+  } catch (error) {
+    database.exec("ROLLBACK");
+    throw error;
+  }
+}
+function taskReadWithEvents(database, project, taskId) {
+  return { task: requireTask(database, project, taskId), events: taskEvents(database, taskId) };
+}
+function listLineageTasks(project, rootAssetId, statuses = activeStatuses) {
+  const normalizedProject = normalizeProject(project);
+  const normalizedStatuses = statuses.map(normalizeStatus);
+  const database = lineageDb();
+  try {
+    requireAsset(database, normalizedProject, rootAssetId);
+    if (normalizedStatuses.length === 0) {
+      return { project: normalizedProject, root_asset_id: rootAssetId, tasks: [], fetchedAt: nowIso() };
+    }
+    const placeholders = normalizedStatuses.map(() => "?").join(",");
+    const rows = database.prepare(`
+      select * from lineage_tasks
+      where project_id = ? and root_asset_id = ? and status in (${placeholders})
+      order by updated_at desc, created_at desc, id
+    `).all(normalizedProject, rootAssetId, ...normalizedStatuses);
+    return { project: normalizedProject, root_asset_id: rootAssetId, tasks: rows.map(taskFromRow), fetchedAt: nowIso() };
+  } finally {
+    database.close();
+  }
+}
+function getLineageTask(project, taskId) {
+  const normalizedProject = normalizeProject(project);
+  const database = lineageDb();
+  try {
+    return { project: normalizedProject, ...taskReadWithEvents(database, normalizedProject, taskId) };
+  } finally {
+    database.close();
+  }
+}
+function upsertLineageTask(project, fields) {
+  const normalizedProject = normalizeProject(project);
+  const taskType = normalizeTaskType(fields.taskType);
+  const taskId = taskIdFor(normalizedProject, fields.rootAssetId, fields.targetAssetId, taskType);
+  const database = lineageDb();
+  try {
+    requireAsset(database, normalizedProject, fields.rootAssetId);
+    requireAsset(database, normalizedProject, fields.targetAssetId);
+    const existing = database.prepare(`
+      select * from lineage_tasks
+      where project_id = ? and root_asset_id = ? and target_asset_id = ? and task_type = ?
+        and status in ('pending', 'claimed', 'in_progress')
+      order by created_at desc limit 1
+    `).get(normalizedProject, fields.rootAssetId, fields.targetAssetId, taskType);
+    const instructions = fields.instructions?.trim() || void 0;
+    if (existing) {
+      const task = taskFromRow(existing);
+      if (task.status !== "pending" && instructions !== void 0 && instructions !== task.instructions) {
+        throw new LineageTaskError("Only pending lineage tasks can update instructions.", 409);
+      }
+      if (task.status === "pending" && instructions !== void 0 && instructions !== task.instructions) {
+        const timestamp2 = nowIso();
+        transaction(database, () => {
+          const result = database.prepare(`
+            update lineage_tasks
+            set instructions = ?, updated_at = ?
+            where id = ? and status = 'pending'
+          `).run(instructions, timestamp2, task.id);
+          assertChanged(result, "Only pending lineage tasks can update instructions.");
+          recordEvent2(database, task.id, "instructions_updated", fields.createdBy, "Instructions updated.");
+        });
+      }
+      return taskWithEvents(database, normalizedProject, task.id);
+    }
+    const closedTask = findTask(database, normalizedProject, taskId);
+    if (closedTask) {
+      const timestamp2 = nowIso();
+      transaction(database, () => {
+        const result = database.prepare(`
+          update lineage_tasks
+          set status = 'pending', instructions = ?, created_by = ?, updated_at = ?,
+            claimed_at = null, started_at = null, resolved_at = null, cancelled_at = null,
+            resolved_generation_job_id = null, resolved_asset_id = null, metadata_json = null
+          where id = ? and status not in ('pending', 'claimed', 'in_progress')
+        `).run(instructions || null, fields.createdBy, timestamp2, taskId);
+        assertChanged(result, "Lineage task changed while reopening.");
+        recordEvent2(database, taskId, "created", fields.createdBy, "Lineage task created.");
+      });
+      return taskWithEvents(database, normalizedProject, taskId);
+    }
+    const timestamp = nowIso();
+    transaction(database, () => {
+      database.prepare(`
+        insert into lineage_tasks (
+          id, project_id, root_asset_id, target_asset_id, task_type, status, instructions,
+          created_by, created_at, updated_at, metadata_json
+        ) values (?, ?, ?, ?, ?, 'pending', ?, ?, ?, ?, null)
+      `).run(taskId, normalizedProject, fields.rootAssetId, fields.targetAssetId, taskType, instructions || null, fields.createdBy, timestamp, timestamp);
+      recordEvent2(database, taskId, "created", fields.createdBy, "Lineage task created.");
+    });
+    return taskWithEvents(database, normalizedProject, taskId);
+  } finally {
+    database.close();
+  }
+}
+function updateLineageTaskInstructions(project, fields) {
+  const normalizedProject = normalizeProject(project);
+  const instructions = fields.instructions.trim();
+  const database = lineageDb();
+  try {
+    const task = requireTask(database, normalizedProject, fields.taskId);
+    if (task.status !== "pending") throw new LineageTaskError("Only pending lineage tasks can update instructions.", 409);
+    const timestamp = nowIso();
+    transaction(database, () => {
+      const result = database.prepare(`
+        update lineage_tasks
+        set instructions = ?, updated_at = ?
+        where id = ? and status = 'pending'
+      `).run(instructions || null, timestamp, task.id);
+      assertChanged(result, "Only pending lineage tasks can update instructions.");
+      recordEvent2(database, task.id, "instructions_updated", "human", "Instructions updated.");
+    });
+    return taskWithEvents(database, normalizedProject, task.id);
+  } finally {
+    database.close();
+  }
+}
+function addLineageTaskComment(project, fields) {
+  const normalizedProject = normalizeProject(project);
+  const actor = normalizeActor(fields.actor, "Comment actor");
+  const message = fields.message.trim();
+  if (!message) throw new LineageTaskError("Comment message is required");
+  const database = lineageDb();
+  try {
+    const task = requireTask(database, normalizedProject, fields.taskId);
+    transaction(database, () => {
+      recordEvent2(database, task.id, "comment_added", actor, message);
+    });
+    return taskWithEvents(database, normalizedProject, task.id);
+  } finally {
+    database.close();
+  }
+}
+function claimLineageTask(project, fields) {
+  const normalizedProject = normalizeProject(project);
+  const agentName = normalizeActor(fields.agentName, "Agent name");
+  const beforeClaimDb = lineageDb();
+  try {
+    const task = requireTask(beforeClaimDb, normalizedProject, fields.taskId);
+    if (task.status !== "pending") throw new LineageTaskError("Only pending lineage tasks can be claimed.", 409);
+  } finally {
+    beforeClaimDb.close();
+  }
+  const claimResult = createAgentClaim({
+    agentName,
+    project: normalizedProject,
+    scopeType: "lineage_task",
+    targetId: fields.taskId,
+    targetTitle: fields.taskId
+  });
+  if (!claimResult.claim) throw new LineageTaskError("Unable to create lineage task claim.", 500);
+  const claim = claimResult.claim;
+  const database = lineageDb();
+  try {
+    const task = requireTask(database, normalizedProject, fields.taskId);
+    if (task.status !== "pending") {
+      releaseAgentClaim(claimResult.claim_token);
+      throw new LineageTaskError("Only pending lineage tasks can be claimed.", 409);
+    }
+    const timestamp = nowIso();
+    const metadata = { ...task.metadata || {}, claim_id: claim.id };
+    try {
+      transaction(database, () => {
+        const result = database.prepare(`
+          update lineage_tasks
+          set status = 'claimed', claimed_at = ?, updated_at = ?, metadata_json = ?
+          where id = ? and status = 'pending'
+        `).run(timestamp, timestamp, metadataJson2(metadata), task.id);
+        assertChanged(result, "Only pending lineage tasks can be claimed.");
+        recordEvent2(database, task.id, "claimed", agentName, "Lineage task claimed.", { claim_id: claim.id });
+      });
+    } catch (error) {
+      releaseAgentClaim(claimResult.claim_token);
+      throw error;
+    }
+    return {
+      ...taskWithEvents(database, normalizedProject, task.id),
+      claim,
+      claim_token: claimResult.claim_token
+    };
+  } finally {
+    database.close();
+  }
+}
+function startLineageTask(project, fields) {
+  const normalizedProject = normalizeProject(project);
+  const precheckDatabase = lineageDb();
+  try {
+    const task = requireTask(precheckDatabase, normalizedProject, fields.taskId);
+    if (task.status !== "claimed") throw new LineageTaskError("Only claimed lineage tasks can be started.", 409);
+  } finally {
+    precheckDatabase.close();
+  }
+  const validation = validateAgentClaimForWrite({
+    claimToken: fields.claimToken,
+    dangerLevel: "enforce",
+    project: normalizedProject,
+    recordEvent: false,
+    scopeType: "lineage_task",
+    targetId: fields.taskId,
+    writeKind: "lineage_task_start"
+  });
+  if (!validation.ok) throw new LineageTaskError(validation.message, 409);
+  const database = lineageDb();
+  try {
+    const task = requireTask(database, normalizedProject, fields.taskId);
+    if (task.status !== "claimed") throw new LineageTaskError("Only claimed lineage tasks can be started.", 409);
+    if (task.claimed_by_claim_id && task.claimed_by_claim_id !== validation.claim.id) {
+      throw new LineageTaskError("Claim token does not match the task claim.", 409);
+    }
+    const timestamp = nowIso();
+    const metadata = { ...task.metadata || {}, claim_id: validation.claim.id };
+    transaction(database, () => {
+      const result = database.prepare(`
+        update lineage_tasks
+        set status = 'in_progress', started_at = ?, updated_at = ?, metadata_json = ?
+        where id = ? and status = 'claimed'
+      `).run(timestamp, timestamp, metadataJson2(metadata), task.id);
+      assertChanged(result, "Only claimed lineage tasks can be started.");
+      recordEvent2(database, task.id, "started", validation.claim.agent_name, "Lineage task started.", { claim_id: validation.claim.id });
+    });
+    recordAgentClaimWriteAllowed(validation.claim, {
+      dangerLevel: "enforce",
+      targetId: fields.taskId,
+      writeKind: "lineage_task_start"
+    });
+    return taskWithEvents(database, normalizedProject, task.id);
+  } finally {
+    database.close();
+  }
+}
+function overrideLineageTask(project, fields) {
+  const normalizedProject = normalizeProject(project);
+  const actor = normalizeActor(fields.actor, "Override actor");
+  const reason = fields.reason.trim();
+  if (!reason) throw new LineageTaskError("Override reason is required");
+  const database = lineageDb();
+  try {
+    const task = requireTask(database, normalizedProject, fields.taskId);
+    if (!["claimed", "in_progress"].includes(task.status)) {
+      throw new LineageTaskError(`Only claimed or in-progress lineage tasks can be overridden; task is ${task.status}.`, 409);
+    }
+    const timestamp = nowIso();
+    const instructions = fields.instructions === void 0 ? task.instructions : fields.instructions.trim() || void 0;
+    const metadata = metadataWithoutClaim(task.metadata);
+    transaction(database, () => {
+      const result = database.prepare(`
+        update lineage_tasks
+        set status = 'pending', instructions = ?, claimed_at = null, started_at = null,
+          updated_at = ?, metadata_json = ?
+        where project_id = ? and id = ? and status in ('claimed', 'in_progress')
+      `).run(instructions || null, timestamp, metadataJson2(metadata), normalizedProject, task.id);
+      assertChanged(result, `Only active lineage task ${task.id} could be overridden.`);
+      if (task.claimed_by_claim_id) {
+        revokeAgentClaimInDatabase(database, normalizedProject, task.claimed_by_claim_id, {
+          actor,
+          reason
+        });
+      }
+      recordEvent2(database, task.id, "human_override", actor, reason, {
+        previous_claim_id: task.claimed_by_claim_id,
+        previous_status: task.status
+      });
+    });
+    return taskWithEvents(database, normalizedProject, task.id);
+  } finally {
+    database.close();
+  }
+}
+function cancelLineageTask(project, fields) {
+  const normalizedProject = normalizeProject(project);
+  const actor = normalizeActor(fields.actor, "Cancel actor");
+  const database = lineageDb();
+  try {
+    const task = requireTask(database, normalizedProject, fields.taskId);
+    if (task.status === "cancelled") return { project: normalizedProject, ok: true, task, events: taskEvents(database, task.id) };
+    if (!["pending", "claimed", "in_progress"].includes(task.status)) {
+      throw new LineageTaskError(`Only open lineage tasks can be cancelled; task is ${task.status}.`, 409);
+    }
+    if (task.status !== "pending" && !fields.override) {
+      throw new LineageTaskError("Cancelling an active lineage task requires override=true.", 409);
+    }
+    const overridingActiveTask = fields.override === true && task.status !== "pending";
+    const metadata = overridingActiveTask ? metadataWithoutClaim(task.metadata) : task.metadata;
+    const timestamp = nowIso();
+    const cancelledTask = {
+      ...task,
+      cancelled_at: timestamp,
+      claimed_at: overridingActiveTask ? void 0 : task.claimed_at,
+      claimed_by_claim_id: overridingActiveTask ? void 0 : task.claimed_by_claim_id,
+      started_at: overridingActiveTask ? void 0 : task.started_at,
+      status: "cancelled",
+      updated_at: timestamp,
+      metadata
+    };
+    if (!fields.confirmWrite) return { project: normalizedProject, ok: true, dryRun: true, task: cancelledTask, events: taskEvents(database, task.id) };
+    transaction(database, () => {
+      const result = database.prepare(`
+        update lineage_tasks
+        set status = 'cancelled', cancelled_at = ?, claimed_at = ?, started_at = ?,
+          updated_at = ?, metadata_json = ?
+        where id = ? and status = ?
+      `).run(
+        timestamp,
+        overridingActiveTask ? null : task.claimed_at || null,
+        overridingActiveTask ? null : task.started_at || null,
+        timestamp,
+        metadataJson2(metadata),
+        task.id,
+        task.status
+      );
+      assertChanged(result, `Only ${task.status} lineage task ${task.id} could be cancelled.`);
+      if (overridingActiveTask) {
+        if (task.claimed_by_claim_id) {
+          revokeAgentClaimInDatabase(database, normalizedProject, task.claimed_by_claim_id, {
+            actor,
+            reason: "Lineage task cancelled by human override."
+          });
+        }
+        recordEvent2(database, task.id, "human_override", actor, "Lineage task cancelled by human override.", {
+          previous_claim_id: task.claimed_by_claim_id,
+          previous_status: task.status
+        });
+      }
+      recordEvent2(database, task.id, "cancelled", actor, "Lineage task cancelled.");
+    });
+    return taskWithEvents(database, normalizedProject, task.id);
+  } finally {
+    database.close();
+  }
+}
+function resolveLineageTask(project, fields) {
+  const normalizedProject = normalizeProject(project);
+  const actor = normalizeActor(fields.actor, "Resolve actor");
+  const database = lineageDb();
+  try {
+    const task = requireTask(database, normalizedProject, fields.taskId);
+    if (fields.resolvedAssetId) requireAsset(database, normalizedProject, fields.resolvedAssetId);
+    if (task.status === "resolved") return { project: normalizedProject, ok: true, task, events: taskEvents(database, task.id) };
+    if (!["pending", "claimed", "in_progress"].includes(task.status)) {
+      throw new LineageTaskError(`Only open lineage tasks can be resolved; task is ${task.status}.`, 409);
+    }
+    const timestamp = nowIso();
+    const resolvedTask = {
+      ...task,
+      status: "resolved",
+      resolved_asset_id: fields.resolvedAssetId,
+      resolved_at: timestamp,
+      resolved_generation_job_id: fields.resolvedGenerationJobId,
+      updated_at: timestamp
+    };
+    if (!fields.confirmWrite) return { project: normalizedProject, ok: true, dryRun: true, task: resolvedTask, events: taskEvents(database, task.id) };
+    transaction(database, () => {
+      const result = database.prepare(`
+        update lineage_tasks
+        set status = 'resolved', resolved_at = ?, resolved_generation_job_id = ?, resolved_asset_id = ?, updated_at = ?
+        where id = ? and status = ?
+      `).run(timestamp, fields.resolvedGenerationJobId || null, fields.resolvedAssetId || null, timestamp, task.id, task.status);
+      assertChanged(result, `Only ${task.status} lineage task ${task.id} could be resolved.`);
+      recordEvent2(database, task.id, "resolved", actor, "Lineage task resolved.", {
+        resolved_asset_id: fields.resolvedAssetId,
+        resolved_generation_job_id: fields.resolvedGenerationJobId
+      });
+    });
+    return taskWithEvents(database, normalizedProject, task.id);
+  } finally {
+    database.close();
+  }
+}
+
 // src/server/assetLineageWorkspaces.ts
 function lineageWorkspaceId(project, rootAssetId) {
   return `${project}:lineage-workspace:${rootAssetId}`;
@@ -1336,7 +2281,71 @@ var LineageError = class extends Error {
   }
   status;
 };
-function requireAsset(database, project, assetId) {
+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 requireAsset2(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);
 }
@@ -1355,6 +2364,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
@@ -1388,7 +2402,7 @@ function lineageWriteClaimContext(database, project, assetId) {
 function getLineageWriteClaimContext(project, assetId) {
   const database = lineageDb();
   try {
-    requireAsset(database, project, assetId);
+    requireAsset2(database, project, assetId);
     return lineageWriteClaimContext(database, project, assetId);
   } finally {
     database.close();
@@ -1400,17 +2414,113 @@ function latestSelectedRoot(database, project) {
 }
 function resolveRoot(database, project, rootAssetId) {
   if (rootAssetId) {
-    requireAsset(database, project, rootAssetId);
+    requireAsset2(database, project, rootAssetId);
     return rootAssetId;
   }
   const root = activeLineageWorkspaceRoot(project) || latestSelectedRoot(database, project);
   if (!root) throw new LineageError("Lineage command requires --root unless a project selection exists");
-  requireAsset(database, project, root);
+  requireAsset2(database, project, root);
   return root;
 }
 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 tasksByTarget(tasks) {
+  const byTarget = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    if (task.task_type !== "iterate" && task.task_type !== "reroll") continue;
+    const existing = byTarget.get(task.target_asset_id) || {};
+    existing[task.task_type] = task;
+    byTarget.set(task.target_asset_id, existing);
+  }
+  return byTarget;
+}
+function withRerollTask(request, task) {
+  return task ? { ...request, task_id: task.id, task } : request;
+}
+function taskBackedRerollRequest(project, rootAssetId, task) {
+  return {
+    id: `${task.id}:request`,
+    project_id: project,
+    root_asset_id: rootAssetId,
+    node_asset_id: task.target_asset_id,
+    status: "pending",
+    requested_by: task.created_by,
+    notes: task.instructions,
+    created_at: task.created_at,
+    task_id: task.id,
+    task
+  };
+}
+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 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));
 }
@@ -1421,8 +2531,8 @@ function localPreviewUrl(project, localPath) {
 }
 function linkLineageAssets(project, fields) {
   const database = lineageDb();
-  requireAsset(database, project, fields.parentAssetId);
-  requireAsset(database, project, fields.childAssetId);
+  requireAsset2(database, project, fields.parentAssetId);
+  requireAsset2(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 {
@@ -1473,20 +2583,37 @@ function descendants(database, project, root) {
 }
 function getLineageSnapshot(project, assetId) {
   const database = lineageDb();
-  requireAsset(database, project, assetId);
+  requireAsset2(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 selected = selectedRows(database, project, root);
+  const tasks = listLineageTasks(project, root).tasks;
+  const ids = [.../* @__PURE__ */ new Set([
+    root,
+    ...edges.flatMap((edge) => [edge.parent_asset_id, edge.child_asset_id]),
+    ...selected.map((row) => row.asset_id),
+    ...tasks.map((task) => task.target_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 selected = selectedRows(database, project, root);
+  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 lineageTasksByNode = tasksByTarget(tasks);
+  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, withRerollTask(request, lineageTasksByNode.get(request.node_asset_id)?.reroll)];
+  }));
   const childIds = new Set(edges.map((edge) => edge.parent_asset_id));
   const selectedIds = new Set(selected.map((row) => row.asset_id));
   const selections = selected.map((row) => ({
@@ -1498,13 +2625,21 @@ 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;
+    const lineageTasks = lineageTasksByNode.get(row.asset_id);
     return {
       ...node,
+      attempt_count: attempts.length,
+      current_attempt: currentAttempt,
       is_latest: !childIds.has(row.asset_id),
+      lineage_tasks: lineageTasks && Object.keys(lineageTasks).length > 0 ? lineageTasks : void 0,
       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)
     };
@@ -1517,6 +2652,7 @@ function getLineageSnapshot(project, assetId) {
     selected: selections.map((row) => row.asset_id),
     selection,
     selections,
+    tasks,
     latest: nodes.filter((node) => node.is_latest).map((node) => node.asset_id),
     nodes,
     edges,
@@ -1528,7 +2664,25 @@ function getLineageNextAsset(project, rootAssetId) {
   const root = resolveRoot(database, project, rootAssetId);
   database.close();
   const snapshot = getLineageSnapshot(project, root);
-  const selectedNodes = snapshot.selected.map((assetId) => snapshot.nodes.find((node) => node.asset_id === assetId)).filter((node) => Boolean(node));
+  const pendingIterateTasks = (snapshot.tasks || []).filter((task) => task.task_type === "iterate" && task.status === "pending");
+  const taskIdsInSelectionOrder = [
+    ...snapshot.selections.map((selection) => selection.asset_id).filter((assetId) => pendingIterateTasks.some((task) => task.target_asset_id === assetId)),
+    ...pendingIterateTasks.map((task) => task.target_asset_id).filter((assetId) => !snapshot.selections.some((selection) => selection.asset_id === assetId))
+  ];
+  const taskSelectedIds = [...new Set(taskIdsInSelectionOrder)];
+  const selectedIds = taskSelectedIds.length > 0 ? taskSelectedIds : snapshot.selected;
+  const selectedNodes = selectedIds.map((assetId) => snapshot.nodes.find((node) => node.asset_id === assetId)).filter((node) => Boolean(node));
+  const taskSelections = taskSelectedIds.map((assetId, position) => {
+    const task = pendingIterateTasks.find((item) => item.target_asset_id === assetId);
+    return {
+      asset_id: assetId,
+      notes: task?.instructions,
+      position,
+      selected_at: task?.created_at || nowIso()
+    };
+  });
+  const selectedSelection = taskSelections.length > 0 ? taskSelections[0] : snapshot.selection;
+  const selectedSelections = taskSelections.length > 0 ? taskSelections : snapshot.selections;
   const latestNodes = snapshot.nodes.filter((node) => snapshot.latest.includes(node.asset_id));
   const warnings = [];
   for (const selectedNode of selectedNodes) {
@@ -1546,9 +2700,9 @@ function getLineageNextAsset(project, rootAssetId) {
       next_asset: selectedNodes[0],
       next_assets: selectedNodes,
       latest: snapshot.latest,
-      selected: snapshot.selected,
-      selection: snapshot.selection,
-      selections: snapshot.selections,
+      selected: selectedIds,
+      selection: selectedSelection,
+      selections: selectedSelections,
       candidates: latestNodes,
       warnings,
       fetchedAt: nowIso()
@@ -1565,9 +2719,9 @@ function getLineageNextAsset(project, rootAssetId) {
       next_asset: latestNodes[0],
       next_assets: [latestNodes[0]],
       latest: snapshot.latest,
-      selected: snapshot.selected,
-      selection: snapshot.selection,
-      selections: snapshot.selections,
+      selected: selectedIds,
+      selection: selectedSelection,
+      selections: selectedSelections,
       candidates: latestNodes,
       warnings,
       fetchedAt: nowIso()
@@ -1583,14 +2737,202 @@ function getLineageNextAsset(project, rootAssetId) {
     next_asset: null,
     next_assets: [],
     latest: snapshot.latest,
-    selected: snapshot.selected,
-    selection: snapshot.selection,
-    selections: snapshot.selections,
+    selected: selectedIds,
+    selection: selectedSelection,
+    selections: selectedSelections,
     candidates: latestNodes,
     warnings,
     fetchedAt: nowIso()
   };
 }
+function listLineageRerollRequests(project, rootAssetId) {
+  const database = lineageDb();
+  try {
+    assertCanonicalRoot(database, project, rootAssetId);
+    const rerollTasks = listLineageTasks(project, rootAssetId).tasks.filter((task) => task.task_type === "reroll");
+    const pendingRerollTasks = listLineageTasks(project, rootAssetId, ["pending"]).tasks.filter((task) => task.task_type === "reroll");
+    const rerollTaskByTarget = new Map(rerollTasks.map((task) => [task.target_asset_id, task]));
+    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);
+    const requests = rows.map((row) => {
+      const request = rerollRequestFrom(row);
+      return withRerollTask(request, rerollTaskByTarget.get(request.node_asset_id));
+    });
+    const legacyTargets = new Set(requests.map((request) => request.node_asset_id));
+    for (const task of pendingRerollTasks) {
+      if (!legacyTargets.has(task.target_asset_id)) requests.push(taskBackedRerollRequest(project, rootAssetId, task));
+    }
+    return { project, root_asset_id: rootAssetId, requests, fetchedAt: nowIso() };
+  } finally {
+    database.close();
+  }
+}
+function recordLineageRerollAttempt(project, fields) {
+  const database = lineageDb();
+  try {
+    assertNodeInRoot(database, project, fields.rootAssetId, fields.nodeAssetId);
+    requireAsset2(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 };
+    const taskResult = upsertLineageTask(project, {
+      createdBy: request.requested_by,
+      instructions: request.notes,
+      rootAssetId: fields.rootAssetId,
+      targetAssetId: fields.nodeAssetId,
+      taskType: "reroll"
+    });
+    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: withRerollTask(rerollRequestFrom(database.prepare("select * from asset_reroll_requests where id = ?").get(request.id)), taskResult.task),
+      task_id: taskResult.task.id,
+      task: taskResult.task
+    };
+  } 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 };
+    const task = listLineageTasks(project, fields.rootAssetId, ["pending"]).tasks.find((item) => item.task_type === "reroll" && item.target_asset_id === fields.nodeAssetId);
+    const cancelledTask = task ? cancelLineageTask(project, {
+      actor: "human",
+      confirmWrite: true,
+      taskId: task.id
+    }).task : void 0;
+    database.prepare(`
+      update asset_reroll_requests
+      set status = 'cancelled', resolved_at = ?
+      where id = ?
+    `).run(timestamp, request.id);
+    return {
+      ok: true,
+      request: withRerollTask(request, cancelledTask),
+      task_id: cancelledTask?.id,
+      task: cancelledTask
+    };
+  } finally {
+    database.close();
+  }
+}
 
 // src/server/assetLineageHandoff.ts
 var publicPackageCommand = "npx @mean-weasel/lineage";
@@ -1603,6 +2945,9 @@ function lineageCommand(command, project, rootAssetId) {
 function linkChildCommand(project, rootAssetId) {
   return `${publicPackageCommand} link-child --project ${shellQuote(project)} --root ${shellQuote(rootAssetId)} --child <asset-id> --confirm-write --db ${shellQuote(lineageDbPath())} --json`;
 }
+function rerollImportGuidance(rootAssetId, targetAssetId) {
+  return `Use lineage reroll plan --root ${rootAssetId} --target ${targetAssetId} and lineage reroll import instead.`;
+}
 function getLineageBrief(project, rootAssetId) {
   const next = getLineageNextAsset(project, rootAssetId);
   const assets = next.next_assets;
@@ -1649,6 +2994,14 @@ function getLineageBrief(project, rootAssetId) {
 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");
+  const rerollRequests = listLineageRerollRequests(project, next.root_asset_id).requests;
+  const pendingRerollForParent = rerollRequests.find((request) => request.node_asset_id === next.next_asset?.asset_id);
+  if (pendingRerollForParent && fields.confirmWrite) {
+    throw new LineageError(
+      `Pending re-roll exists for ${pendingRerollForParent.node_asset_id}. lineage link-child creates a visible child variation edge; it does not re-roll the same node. ${rerollImportGuidance(next.root_asset_id, pendingRerollForParent.node_asset_id)} Cancel the re-roll first if you intentionally want a new child variation.`,
+      409
+    );
+  }
   if (fields.confirmWrite) {
     const claimContext = getLineageWriteClaimContext(project, next.next_asset.asset_id);
     const validation = validateAgentClaimForWrite({
@@ -1675,21 +3028,325 @@ function linkSelectedLineageChild(project, fields) {
     parent_asset_id: next.next_asset.asset_id,
     child_asset_id: fields.childAssetId,
     reference_asset_ids: next.next_assets.map((asset) => asset.asset_id),
-    warning: next.next_assets.length > 1 ? "Linked child to the primary selected base; add explicit edges to other selected references if the child derives from them too." : void 0
+    warning: [
+      pendingRerollForParent ? `Pending re-roll exists for ${pendingRerollForParent.node_asset_id}. link-child would create a visible child variation; use reroll plan/import to update the same node attempt.` : void 0,
+      rerollRequests.length > 0 && !pendingRerollForParent ? `This lineage has ${rerollRequests.length} pending re-roll target(s). link-child is only for new visible child variations, not re-roll attempts.` : void 0,
+      next.next_assets.length > 1 ? "Linked child to the primary selected base; add explicit edges to other selected references if the child derives from them too." : void 0
+    ].filter(Boolean).join(" ") || void 0
   };
 }
 
+// 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: "reroll 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: "reroll 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 rerollTask = listLineageTasks(project, job.root_asset_id).tasks.find((task) => task.task_type === "reroll" && task.target_asset_id === target[0].asset_id);
+    if (rerollTask) {
+      resolveLineageTask(project, {
+        actor: "agent",
+        confirmWrite: true,
+        resolvedAssetId: resolved.assetId,
+        resolvedGenerationJobId: fields.jobId,
+        taskId: rerollTask.id
+      });
+    }
+    const importedJob = loadGenerationJob(writeDb, project, fields.jobId);
+    return { ok: true, command: "reroll 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";
@@ -1697,9 +3354,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}=`;
@@ -1717,15 +3374,15 @@ 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"),
     port
   };
 }
-function printHelp(config) {
-  console.log(`${config.binName} ${packageVersion()}
+function formatLineageHelp(config) {
+  return `${config.binName} ${packageVersion()}
 
 Usage:
   ${config.binName} start [--port <port>] [--host <host>] [--db <path>] [--open] [--json]
@@ -1733,6 +3390,19 @@ 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} tasks list --root <asset-id> [--project <project>] [--db <path>] [--json]
+  ${config.binName} tasks inspect --task <task-id> [--project <project>] [--db <path>] [--json]
+  ${config.binName} tasks claim --task <task-id> --agent-name <name> [--project <project>] [--db <path>] [--json]
+  ${config.binName} tasks start --task <task-id> --claim-token <claim-id.secret> [--project <project>] [--db <path>] [--json]
+  ${config.binName} tasks comment --task <task-id> --message <text> [--project <project>] [--db <path>] [--json]
+  ${config.binName} tasks cancel --task <task-id> [--confirm-write] [--override] [--project <project>] [--db <path>] [--json]
+  ${config.binName} tasks override --task <task-id> --reason <text> [--instructions <text>] [--project <project>] [--db <path>] [--json]
+  ${config.binName} tasks instructions --task <task-id> --instructions <text> [--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]
@@ -1744,7 +3414,14 @@ Usage:
   ${config.binName} --help
   ${config.binName} --version
 
-${config.displayName} runs the bundled Lineage server for the ${config.channel} channel.`);
+${config.displayName} runs the bundled Lineage server for the ${config.channel} channel.
+
+Variation vs re-roll:
+  link-child creates a new visible child variation edge.
+  reroll mark -> reroll plan -> reroll import updates the same node with a new attempt.`;
+}
+function printHelp(config) {
+  console.log(formatLineageHelp(config));
 }
 function openBrowser(url) {
   const command = platform() === "darwin" ? "open" : platform() === "win32" ? "cmd" : "xdg-open";
@@ -1796,8 +3473,123 @@ 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}`);
+  }
+  if (command === "tasks") {
+    const subcommand = positionalArgs(args)[0] || "";
+    const taskId = readOption(args, "--task");
+    if (subcommand === "list") {
+      if (!options.rootAssetId) throw new Error("lineage tasks list requires --root");
+      return listLineageTasks(options.project, options.rootAssetId);
+    }
+    if (subcommand === "inspect") {
+      if (!taskId) throw new Error("lineage tasks inspect requires --task");
+      return getLineageTask(options.project, taskId);
+    }
+    if (subcommand === "claim") {
+      const agentName = readOption(args, "--agent-name");
+      if (!taskId) throw new Error("lineage tasks claim requires --task");
+      if (!agentName) throw new Error("lineage tasks claim requires --agent-name");
+      return claimLineageTask(options.project, { taskId, agentName });
+    }
+    if (subcommand === "start") {
+      if (!taskId) throw new Error("lineage tasks start requires --task");
+      if (!options.claimToken) throw new Error("lineage tasks start requires --claim-token");
+      return startLineageTask(options.project, { taskId, claimToken: options.claimToken });
+    }
+    if (subcommand === "comment") {
+      const message = readOption(args, "--message");
+      if (!taskId) throw new Error("lineage tasks comment requires --task");
+      if (!message) throw new Error("lineage tasks comment requires --message");
+      return addLineageTaskComment(options.project, {
+        actor: readOption(args, "--actor") || "human",
+        message,
+        taskId
+      });
+    }
+    if (subcommand === "cancel") {
+      if (!taskId) throw new Error("lineage tasks cancel requires --task");
+      return cancelLineageTask(options.project, {
+        actor: readOption(args, "--actor") || "human",
+        confirmWrite: options.confirmWrite,
+        override: args.includes("--override"),
+        taskId
+      });
+    }
+    if (subcommand === "override") {
+      const reason = readOption(args, "--reason");
+      if (!taskId) throw new Error("lineage tasks override requires --task");
+      if (!reason) throw new Error("lineage tasks override requires --reason");
+      return overrideLineageTask(options.project, {
+        actor: readOption(args, "--actor") || "human",
+        instructions: readOption(args, "--instructions"),
+        reason,
+        taskId
+      });
+    }
+    if (subcommand === "instructions") {
+      const instructions = readOption(args, "--instructions");
+      if (!taskId) throw new Error("lineage tasks instructions requires --task");
+      if (instructions === void 0) throw new Error("lineage tasks instructions requires --instructions");
+      return updateLineageTaskInstructions(options.project, { instructions, taskId });
+    }
+    throw new Error(`Unknown tasks 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));
@@ -1824,8 +3616,43 @@ function printDataResult(command, result, json) {
   if (command === "link-child" && result && typeof result === "object") {
     const link = result;
     console.log(link.message || `${link.dryRun ? "Dry run: " : ""}Link ${link.edge?.child_asset_id || "child"} from ${link.edge?.parent_asset_id || "parent"}`);
+    if (link.warning) console.log(`Warning: ${link.warning}`);
     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;
+    }
+  }
+  if (command === "tasks" && result && typeof result === "object") {
+    if ("tasks" in result) {
+      const listed = result;
+      console.log(`${listed.tasks.length} lineage task(s)`);
+      for (const task of listed.tasks) console.log(`${task.id} ${task.task_type} ${task.status} ${task.target_asset_id}`);
+      return;
+    }
+    if ("task" in result) {
+      const mutation = result;
+      const prefix = mutation.dryRun ? "Dry run: " : "";
+      console.log(`${prefix}${mutation.task?.id || "task"} ${mutation.task?.task_type || "task"} ${mutation.task?.status || "unknown"} ${mutation.task?.target_asset_id || ""}`.trim());
+      if ("claim_token" in mutation && typeof mutation.claim_token === "string") console.log(`Token: ${mutation.claim_token}`);
+      if (mutation.events && mutation.events.length > 0) console.log(`Events: ${mutation.events.map((event) => event.event_type).join(", ")}`);
+      return;
+    }
+  }
   console.log(String(result));
 }
 function runLineageAgentCommand(command, args) {
@@ -1954,8 +3781,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}`);
@@ -2009,7 +3836,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" || command === "tasks") {
     const commandArgs = normalizedArgs.slice(1);
     const json2 = commandArgs.includes("--json");
     try {