@mean-weasel/lineage 0.1.6 → 0.1.7

package/dist/cli/lineage-dev.js

@@ -615,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),
@@ -920,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,
@@ -959,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}`);
@@ -1029,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 = []) {
@@ -1339,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();
@@ -1356,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.");
@@ -1376,11 +1632,13 @@ 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();
@@ -1400,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}`;
@@ -1586,7 +2345,7 @@ function indexLineageAssets(project = defaultProject) {
   database.close();
   return { catalog: catalog.length, local: local.length, total: catalog.length + local.length, database: lineageDbPath() };
 }
-function requireAsset(database, project, assetId) {
+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);
 }
@@ -1606,7 +2365,7 @@ function rootFor(database, project, assetId) {
   return assetId;
 }
 function assertCanonicalRoot(database, project, root) {
-  requireAsset(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);
 }
@@ -1643,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();
@@ -1655,12 +2414,12 @@ 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) {
@@ -1685,6 +2444,33 @@ function rerollRequestFrom(row) {
     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),
@@ -1724,7 +2510,7 @@ function withImplicitAttempt(physicalAttempts, row) {
 }
 function assertNodeInRoot(database, project, root, node) {
   assertCanonicalRoot(database, project, root);
-  requireAsset(database, project, node);
+  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}`);
 }
@@ -1745,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 {
@@ -1797,10 +2583,17 @@ 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,
@@ -1815,12 +2608,12 @@ function getLineageSnapshot(project, assetId) {
   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, request];
+    return [request.node_asset_id, withRerollTask(request, lineageTasksByNode.get(request.node_asset_id)?.reroll)];
   }));
-  const selected = selectedRows(database, project, root);
   const childIds = new Set(edges.map((edge) => edge.parent_asset_id));
   const selectedIds = new Set(selected.map((row) => row.asset_id));
   const selections = selected.map((row) => ({
@@ -1837,11 +2630,13 @@ function getLineageSnapshot(project, assetId) {
     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, previewPath) ? localPreviewUrl(project, previewPath) : void 0,
       reroll_request: rerollsByNode.get(row.asset_id),
@@ -1857,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,
@@ -1868,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) {
@@ -1886,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()
@@ -1905,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()
@@ -1923,9 +2737,9 @@ 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()
@@ -1935,12 +2749,23 @@ 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);
-    return { project, root_asset_id: rootAssetId, requests: rows.map(rerollRequestFrom), fetchedAt: nowIso() };
+    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();
   }
@@ -1949,7 +2774,7 @@ function recordLineageRerollAttempt(project, fields) {
   const database = lineageDb();
   try {
     assertNodeInRoot(database, project, fields.rootAssetId, fields.nodeAssetId);
-    requireAsset(database, project, fields.assetId);
+    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);
@@ -2038,6 +2863,13 @@ function markLineageRerollRequest(project, fields) {
       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
@@ -2057,7 +2889,12 @@ function markLineageRerollRequest(project, fields) {
         review_state = excluded.review_state, reviewed_at = excluded.reviewed_at,
         ignored_at = excluded.ignored_at, notes = coalesce(excluded.notes, asset_reviews.notes), updated_at = excluded.updated_at
     `).run(fields.nodeAssetId, timestamp, request.notes || null, timestamp);
-    return { ok: true, request: rerollRequestFrom(database.prepare("select * from asset_reroll_requests where id = ?").get(request.id)) };
+    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();
   }
@@ -2075,12 +2912,23 @@ function clearLineageRerollRequest(project, fields) {
     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 };
+    return {
+      ok: true,
+      request: withRerollTask(request, cancelledTask),
+      task_id: cancelledTask?.id,
+      task: cancelledTask
+    };
   } finally {
     database.close();
   }
@@ -2097,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;
@@ -2143,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({
@@ -2169,7 +3028,11 @@ 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
   };
 }
 
@@ -2359,7 +3222,7 @@ function planImageReroll(project = defaultProject, fields) {
       created_at: timestamp
     }]
   };
-  if (fields.dryRun) return { ok: true, command: "generate image plan", project, dryRun: true, wouldWrite: true, job: preview };
+  if (fields.dryRun) return { ok: true, command: "reroll plan", project, dryRun: true, wouldWrite: true, job: preview };
   const database = lineageDb();
   try {
     database.exec("BEGIN IMMEDIATE");
@@ -2377,7 +3240,7 @@ function planImageReroll(project = defaultProject, fields) {
       database.exec("ROLLBACK");
       throw error;
     }
-    return { ok: true, command: "generate image plan", project, job: loadGenerationJob(database, project, id) };
+    return { ok: true, command: "reroll plan", project, job: loadGenerationJob(database, project, id) };
   } finally {
     database.close();
   }
@@ -2456,8 +3319,18 @@ function importImageRerollOutput(project = defaultProject, fields) {
       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: "generate image import", project, job: importedJob, imported: importedJob.outputs };
+    return { ok: true, command: "reroll import", project, job: importedJob, imported: importedJob.outputs };
   } finally {
     writeDb.close();
   }
@@ -2508,8 +3381,8 @@ function resolveStartOptions(config, args) {
     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]
@@ -2522,6 +3395,14 @@ Usage:
   ${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]
@@ -2533,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";
@@ -2636,6 +3524,66 @@ function runLineageDataCommand(command, args) {
     }
     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) {
@@ -2668,6 +3616,7 @@ 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") {
@@ -2688,6 +3637,22 @@ function printDataResult(command, result, json) {
       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) {
@@ -2871,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" || command === "reroll") {
+  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 {