@mean-weasel/lineage 0.1.6 → 0.1.8

package/dist/cli/lineage-dev.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli/lineageCli.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir, platform } from "node:os";
-import { dirname as dirname3, join as join6, resolve as resolve4 } from "node:path";
+import { dirname as dirname3, join as join6, resolve as resolve5 } from "node:path";
 import { spawn } from "node:child_process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
@@ -328,6 +328,13 @@ function catalogPath(project = defaultProject) {
 function fixtureCatalogPath(project = defaultProject) {
   return join3(repoRoot, "fixtures", cleanProject(project), "assets", "catalog.json");
 }
+function resolvedCatalogPath(project = defaultProject) {
+  const path = catalogPath(project);
+  if (existsSync3(path)) return path;
+  const clean = cleanProject(project);
+  if (clean === defaultProject && existsSync3(fixtureCatalogPath(clean))) return fixtureCatalogPath(clean);
+  return path;
+}
 function normalizeCatalog(catalog, fallbackProject = defaultProject) {
   const project = cleanProject(catalog.project || catalog.product || fallbackProject);
   const product = catalog.product || project;
@@ -570,6 +577,10 @@ function listAssets(project = defaultProject, options = {}) {
     error
   };
 }
+function validateProject(project = defaultProject) {
+  const catalog = loadCatalog(project);
+  return { project: catalog.project, product: catalog.product, catalogPath: resolvedCatalogPath(project), default_bucket: catalog.default_bucket, default_region: catalog.default_region, asset_count: catalog.assets.length };
+}
 
 // src/server/assetLineageDb.ts
 var require2 = createRequire(import.meta.url);
@@ -615,6 +626,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 +935,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 +1011,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 +1144,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 +1580,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 +1610,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 +1643,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 +1669,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}`;
@@ -1464,6 +2234,17 @@ function seedLegacyWorkspaces(database, project) {
     );
   }
 }
+function listRows(database, project) {
+  return database.prepare(`
+    select * from lineage_workspaces
+    where project_id = ?
+    order by
+      case status when 'active' then 0 when 'paused' then 1 else 2 end,
+      active_at desc nulls last,
+      updated_at desc,
+      title
+  `).all(project).map(rowToWorkspace);
+}
 function activeWorkspace(database, project) {
   const row = database.prepare(`
     select * from lineage_workspaces
@@ -1473,6 +2254,20 @@ function activeWorkspace(database, project) {
   `).get(project);
   return row ? rowToWorkspace(row) : null;
 }
+function listLineageWorkspaces(project) {
+  const database = lineageDb();
+  try {
+    seedLegacyWorkspaces(database, project);
+    return {
+      project,
+      active_workspace: activeWorkspace(database, project),
+      workspaces: listRows(database, project),
+      fetchedAt: nowIso()
+    };
+  } finally {
+    database.close();
+  }
+}
 function activeLineageWorkspaceRoot(project) {
   const database = lineageDb();
   try {
@@ -1586,7 +2381,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 +2401,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 +2438,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 +2450,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 +2480,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 +2546,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 +2567,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 +2619,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 +2644,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 +2666,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 +2688,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 +2700,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 +2736,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 +2755,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 +2773,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 +2785,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 +2810,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 +2899,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 +2925,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 +2948,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 +2981,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 +3030,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 +3064,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 +3258,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 +3276,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,20 +3355,251 @@ 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();
   }
 }
 
+// src/server/lineageSelectionPacket.ts
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync5, statSync as statSync4 } from "node:fs";
+import { isAbsolute, resolve as resolve4 } from "node:path";
+var LineageSelectionPacketError = class extends Error {
+  constructor(message, warnings = [], errors = []) {
+    super(message);
+    this.warnings = warnings;
+    this.errors = errors;
+  }
+  warnings;
+  errors;
+};
+function listAllAssets(project) {
+  const pageSize = 100;
+  const first = listAssets(project, { page: 1, pageSize, source: "all" });
+  const assets = [...first.assets];
+  for (let page = 2; page <= first.pagination.totalPages; page += 1) {
+    assets.push(...listAssets(project, { page, pageSize, source: "all" }).assets);
+  }
+  return assets;
+}
+function resolveWorkspace(project, options) {
+  if (options.rootAssetId && options.workspaceId) {
+    throw new LineageSelectionPacketError("Use either --root or --workspace, not both.", [], ["ambiguous_workspace"]);
+  }
+  const snapshot = listLineageWorkspaces(project);
+  const target = options.workspaceId || options.rootAssetId;
+  const workspace = target ? snapshot.workspaces.find((item) => item.id === target || item.root_asset_id === target) : snapshot.active_workspace;
+  if (workspace) return workspace;
+  if (options.rootAssetId) {
+    return {
+      id: lineageWorkspaceId(project, options.rootAssetId),
+      project,
+      root_asset_id: options.rootAssetId,
+      title: `${options.rootAssetId} lineage`,
+      status: "active",
+      created_by: "system",
+      created_at: "",
+      updated_at: ""
+    };
+  }
+  const message = options.workspaceId ? `Unknown lineage workspace: ${options.workspaceId}` : "No active lineage workspace. Pass --root or activate a workspace first.";
+  throw new LineageSelectionPacketError(message, [], [options.workspaceId ? "unknown_workspace" : "missing_active_workspace"]);
+}
+function resolveLocalReference(reference) {
+  if (!reference) return void 0;
+  if (isAbsolute(reference)) return reference;
+  const repoRelative = resolve4(repoRoot, reference);
+  if (existsSync5(repoRelative)) return repoRelative;
+  return resolve4(repoRoot, ".asset-scratch", reference);
+}
+function fileSize(path) {
+  if (!path || !existsSync5(path)) return void 0;
+  try {
+    return statSync4(path).size;
+  } catch {
+    return void 0;
+  }
+}
+function storageState(hasLocal, hasS3) {
+  if (hasLocal && hasS3) return "local_and_s3";
+  if (hasLocal) return "local_only";
+  if (hasS3) return "s3_backed";
+  return "unresolved";
+}
+function currentAttemptFor(node) {
+  if (!node.current_attempt) return void 0;
+  return {
+    asset_id: node.current_attempt.asset_id,
+    checksum_sha256: node.current_attempt.checksum_sha256,
+    file_path: node.current_attempt.file_path,
+    generation_job_id: node.current_attempt.generation_job_id,
+    id: node.current_attempt.id,
+    is_current: node.current_attempt.is_current,
+    source: node.current_attempt.source
+  };
+}
+function assetForNode(node, catalogAsset, warnings) {
+  const localReference = catalogAsset?.local?.absolute_path || node.current_attempt?.file_path || node.local_path || catalogAsset?.local?.relative_path;
+  const absolutePath = catalogAsset?.local?.absolute_path || resolveLocalReference(localReference);
+  const localExists = absolutePath ? existsSync5(absolutePath) : false;
+  const hasLocalClaim = Boolean(absolutePath || node.local_path || catalogAsset?.local?.relative_path);
+  const s3Key = catalogAsset?.s3?.key || node.s3_key;
+  const hasS3 = Boolean(s3Key);
+  const checksum = catalogAsset?.local?.checksum_sha256 || node.current_attempt?.checksum_sha256 || node.checksum_sha256 || catalogAsset?.s3?.checksum_sha256;
+  const mimeType = catalogAsset?.local?.content_type || catalogAsset?.s3?.content_type;
+  const mediaType = catalogAsset?.content_type || node.media_type;
+  if (hasLocalClaim && !localExists) warnings.push(`Selected asset ${node.asset_id} has a local path but the file is missing: ${absolutePath || node.local_path}`);
+  if (!hasLocalClaim && !hasS3) warnings.push(`Selected asset ${node.asset_id} has neither a local file nor S3 key.`);
+  if (mediaType && mediaType !== "image" && mediaType !== "gif") warnings.push(`Selected asset ${node.asset_id} is ${mediaType}, not an image/gif asset.`);
+  return {
+    asset_id: node.asset_id,
+    campaign: catalogAsset?.campaign || node.campaign,
+    channel: catalogAsset?.channel || node.channel,
+    checksum_sha256: checksum,
+    current_attempt: currentAttemptFor(node),
+    local: {
+      absolute_path: absolutePath,
+      content_type: catalogAsset?.local?.content_type,
+      exists: localExists,
+      relative_path: catalogAsset?.local?.relative_path || node.local_path || node.current_attempt?.file_path,
+      size_bytes: catalogAsset?.local?.size_bytes || fileSize(absolutePath)
+    },
+    media_type: mediaType,
+    mime_type: mimeType,
+    review_notes: node.review_notes,
+    review_state: node.review_state,
+    s3: {
+      bucket: catalogAsset?.s3?.bucket,
+      checksum_sha256: catalogAsset?.s3?.checksum_sha256,
+      content_type: catalogAsset?.s3?.content_type,
+      etag: catalogAsset?.s3?.etag,
+      key: s3Key,
+      region: catalogAsset?.s3?.region,
+      size_bytes: catalogAsset?.s3?.size_bytes,
+      version_id: catalogAsset?.s3?.version_id
+    },
+    selection_note: node.selection_note,
+    source: catalogAsset?.source || node.source,
+    status: catalogAsset?.status || node.status,
+    storage_state: storageState(hasLocalClaim, hasS3),
+    title: catalogAsset?.title || node.title || node.asset_id
+  };
+}
+function packetId(packetIdentity) {
+  const digest = createHash3("sha256").update(JSON.stringify(packetIdentity)).digest("hex").slice(0, 24);
+  return `lineage_packet_${digest}`;
+}
+function getLineageSelectionPacket(project, options = {}) {
+  const workspace = resolveWorkspace(project, options);
+  const snapshot = getLineageSnapshot(project, workspace.root_asset_id);
+  const catalogSummary = validateProject(project);
+  const catalogAssets = listAllAssets(project);
+  const catalogById = new Map(catalogAssets.map((asset) => [asset.asset_id, asset]));
+  const warnings = [];
+  const errors = [];
+  const nodeById = new Map(snapshot.nodes.map((node) => [node.asset_id, node]));
+  const selectedItems = snapshot.selections.map((selection) => ({
+    asset_id: selection.asset_id,
+    position: selection.position,
+    selected_at: selection.selected_at,
+    selection_note: selection.notes
+  }));
+  if (selectedItems.length === 0) warnings.push(`Lineage workspace ${workspace.id} has no selected assets.`);
+  const assets = selectedItems.flatMap((item) => {
+    const node = nodeById.get(item.asset_id);
+    if (!node) {
+      const message = `Selected asset ${item.asset_id} is not present in the resolved workspace snapshot.`;
+      warnings.push(message);
+      errors.push("selected_asset_outside_workspace");
+      return [];
+    }
+    return [assetForNode(node, catalogById.get(item.asset_id), warnings)];
+  });
+  if (assets.some((asset) => !asset.dimensions)) warnings.push("Image dimensions are unavailable for one or more selected assets.");
+  if (options.strict) {
+    const strictErrors = [
+      ...selectedItems.length === 0 ? ["empty_selection"] : [],
+      ...assets.filter((asset) => asset.local.absolute_path && !asset.local.exists).map((asset) => `missing_local_file:${asset.asset_id}`),
+      ...errors
+    ];
+    if (strictErrors.length > 0) {
+      throw new LineageSelectionPacketError(`Lineage selection packet strict mode failed: ${strictErrors.join(", ")}`, warnings, strictErrors);
+    }
+  }
+  const context = {
+    campaign: options.campaign,
+    channel: options.channel,
+    labels: options.labels || [],
+    notes: options.contextNotes
+  };
+  const identity = {
+    assets: assets.map((asset) => ({
+      asset_id: asset.asset_id,
+      checksum_sha256: asset.checksum_sha256,
+      local_path: asset.local.absolute_path,
+      s3_key: asset.s3.key,
+      storage_state: asset.storage_state
+    })),
+    context,
+    project,
+    root_asset_id: workspace.root_asset_id,
+    schema_version: "lineage.selection_packet.v1",
+    selection: selectedItems,
+    workspace_id: workspace.id
+  };
+  return {
+    assets,
+    context,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    errors,
+    kind: "lineage.selection_packet",
+    packet_id: packetId(identity),
+    product: catalogSummary.product,
+    project,
+    schema_version: "lineage.selection_packet.v1",
+    selection: {
+      asset_ids: selectedItems.map((item) => item.asset_id),
+      count: selectedItems.length,
+      items: selectedItems,
+      root_asset_id: workspace.root_asset_id
+    },
+    source: {
+      app: "lineage",
+      command: options.command,
+      db_path: options.dbPath || process.env.LINEAGE_DB || lineageDbPath(),
+      package: options.packageVersion
+    },
+    warnings: [...new Set(warnings)],
+    workspace: {
+      active_at: workspace.active_at,
+      id: workspace.id,
+      notes: workspace.notes,
+      root_asset_id: workspace.root_asset_id,
+      status: workspace.status,
+      title: workspace.title
+    }
+  };
+}
+
 // src/cli/lineageCli.ts
 var signalExitCodes = {
   SIGINT: 130,
   SIGTERM: 143
 };
 function packageRoot() {
-  return resolve4(dirname3(fileURLToPath2(import.meta.url)), "..", "..");
+  return resolve5(dirname3(fileURLToPath2(import.meta.url)), "..", "..");
 }
 function packageVersion() {
   try {
@@ -2493,6 +3623,19 @@ function readOption(args, name) {
   if (index >= 0) return args[index + 1];
   return void 0;
 }
+function readOptions(args, name) {
+  const values = [];
+  const prefix = `${name}=`;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg.startsWith(prefix)) values.push(arg.slice(prefix.length));
+    else if (arg === name && args[index + 1] && !args[index + 1].startsWith("--")) {
+      values.push(args[index + 1]);
+      index += 1;
+    }
+  }
+  return values;
+}
 function resolveStartOptions(config, args) {
   const runtimeDir = dataRoot(config.displayName);
   const rawPort = readOption(args, "--port") || process.env.PORT || String(config.defaultPort);
@@ -2508,20 +3651,29 @@ 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]
   ${config.binName} next [--project <project>] [--root <asset-id>] [--db <path>] [--json]
   ${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} selection packet [--project <project>] [--workspace <id-or-root>|--root <asset-id>] [--channel <channel>] [--campaign <campaign>] [--context-notes <text>] [--label <label>] [--out <path>] [--strict] [--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]
@@ -2533,7 +3685,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";
@@ -2576,6 +3735,31 @@ function runLineageDataCommand(command, args) {
     if (!options.assetId) throw new Error("lineage inspect requires --asset-id");
     return getLineageSnapshot(options.project, options.assetId);
   }
+  if (command === "selection") {
+    const subcommand = positionalArgs(args)[0] || "";
+    if (subcommand !== "packet") throw new Error(`Unknown selection command: ${subcommand}`);
+    const labels = readOptions(args, "--label").flatMap((label) => label.split(",")).map((label) => label.trim()).filter(Boolean);
+    const packet = getLineageSelectionPacket(options.project, {
+      campaign: readOption(args, "--campaign"),
+      channel: readOption(args, "--channel"),
+      command: "lineage selection packet",
+      contextNotes: readOption(args, "--context-notes") || readOption(args, "--notes"),
+      dbPath: options.dbPath,
+      labels,
+      packageVersion: packageVersion(),
+      rootAssetId: options.rootAssetId,
+      strict: args.includes("--strict"),
+      workspaceId: readOption(args, "--workspace") || readOption(args, "--workspace-id")
+    });
+    const out = readOption(args, "--out");
+    if (out) {
+      const outPath = resolve5(out);
+      mkdirSync4(dirname3(outPath), { recursive: true });
+      writeFileSync2(outPath, `${JSON.stringify(packet, null, 2)}
+`);
+    }
+    return packet;
+  }
   if (command === "link-child") {
     if (!options.childAssetId) throw new Error("lineage link-child requires --child");
     return linkSelectedLineageChild(options.project, {
@@ -2636,6 +3820,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) {
@@ -2665,9 +3909,17 @@ function printDataResult(command, result, json) {
     console.log(`Active: ${snapshot.active_asset_id}`);
     return;
   }
+  if (command === "selection" && result && typeof result === "object" && "packet_id" in result) {
+    const packet = result;
+    console.log(`${packet.packet_id}: ${packet.selection?.count || packet.assets?.length || 0} selected asset(s)`);
+    if (packet.workspace?.root_asset_id) console.log(`Root: ${packet.workspace.root_asset_id}`);
+    for (const warning of packet.warnings || []) console.log(`Warning: ${warning}`);
+    return;
+  }
   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 +3940,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) {
@@ -2817,7 +4085,7 @@ function start(config, args) {
     process.exit(1);
   }
   const serverPath = join6(packageRoot(), "dist", "server.js");
-  if (!existsSync5(serverPath)) {
+  if (!existsSync6(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}`);
@@ -2871,7 +4139,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 === "selection" || command === "link-child" || command === "reroll" || command === "tasks") {
     const commandArgs = normalizedArgs.slice(1);
     const json2 = commandArgs.includes("--json");
     try {