content: {
  status: "active" | "paused",
  trigger_type: "manual" | "cron" | "entity_created" | "field_changed",
  trigger_config: { schedule?, field?, to_value? },
  steps: [{ order, agent_slug, prompt, for_each? }]
}

CREATE TABLE tasks (
  id              uuid PRIMARY KEY DEFAULT gen_random_uuid(),
  tenant_id       uuid NOT NULL REFERENCES tenants(id) ON DELETE CASCADE,

  -- Scope: where this task applies (all nullable — standalone tasks have only tenant_id)
  entity_type_id  uuid REFERENCES entity_types(id) ON DELETE CASCADE,
  entity_id       uuid REFERENCES entities(id) ON DELETE CASCADE,

  -- Hierarchy
  parent_id       uuid REFERENCES tasks(id) ON DELETE CASCADE,
  depends_on      text[] NOT NULL DEFAULT '{}',
  sort_order      integer NOT NULL DEFAULT 0,

  -- Definition
  name            text NOT NULL,
  slug            text NOT NULL,
  description     text,
  instructions    text,
  completion_criteria text,

  -- Assignment: agent, human, or unassigned (claimable by anyone)
  agent_slug      text,                   -- assigned agent (null = not agent-assigned)
  assigned_to     uuid REFERENCES profiles(id),  -- assigned human (null = not human-assigned)
  -- Both null = unassigned, claimable by any agent or human with access

  -- Trigger
  trigger_type    text NOT NULL DEFAULT 'manual'
                  CHECK (trigger_type IN (
                    'manual', 'entity_created', 'entity_updated',
                    'field_changed', 'cron', 'webhook'
                  )),
  trigger_config  jsonb NOT NULL DEFAULT '{}',

  -- Output
  output_type     text
                  CHECK (output_type IS NULL OR output_type IN (
                    'field', 'fields', 'entity', 'entities',
                    'relation-entity', 'document', 'status', 'none'
                  )),
  output_config   jsonb NOT NULL DEFAULT '{}',

  -- State
  status          text NOT NULL DEFAULT 'active'
                  CHECK (status IN ('draft', 'active', 'paused', 'disabled', 'completed')),
  is_system       boolean NOT NULL DEFAULT false,

  -- Runtime metadata (updated after runs)
  last_run_at     timestamptz,
  last_run_status text,
  run_count       integer NOT NULL DEFAULT 0,

  -- Config
  metadata        jsonb NOT NULL DEFAULT '{}',

  -- Audit
  created_by      uuid REFERENCES profiles(id),
  created_at      timestamptz NOT NULL DEFAULT now(),
  updated_at      timestamptz NOT NULL DEFAULT now(),

  -- No scope_check constraint — tasks can be standalone (just tenant_id)
  -- Standalone: backlog items like "set up CRM integration"
  -- Type-level: templates like "extract fields" (inherited by all entities)
  -- Entity-level: specific work like "email prospects about this article"
  -- Child: subtask with parent_id

  CONSTRAINT tasks_slug_unique
    UNIQUE NULLS NOT DISTINCT (tenant_id, entity_type_id, entity_id, parent_id, slug)
);

CREATE INDEX idx_tasks_tenant ON tasks(tenant_id);
CREATE INDEX idx_tasks_type ON tasks(tenant_id, entity_type_id)
  WHERE entity_type_id IS NOT NULL;
CREATE INDEX idx_tasks_entity ON tasks(tenant_id, entity_id)
  WHERE entity_id IS NOT NULL;
CREATE INDEX idx_tasks_parent ON tasks(parent_id)
  WHERE parent_id IS NOT NULL;
CREATE INDEX idx_tasks_trigger ON tasks(tenant_id, trigger_type, status)
  WHERE status = 'active';
CREATE INDEX idx_tasks_cron ON tasks(tenant_id)
  WHERE trigger_type = 'cron' AND status = 'active';
CREATE INDEX idx_tasks_agent ON tasks(tenant_id, agent_slug)
  WHERE agent_slug IS NOT NULL AND status = 'active';
CREATE INDEX idx_tasks_user ON tasks(tenant_id, assigned_to)
  WHERE assigned_to IS NOT NULL AND status IN ('active', 'draft');
CREATE INDEX idx_tasks_backlog ON tasks(tenant_id, status)
  WHERE agent_slug IS NULL AND assigned_to IS NULL AND status = 'active';

ALTER TABLE workflow_node_runs
  ADD COLUMN task_id uuid REFERENCES tasks(id) ON DELETE SET NULL;

CREATE INDEX idx_workflow_node_runs_task ON workflow_node_runs(task_id)
  WHERE task_id IS NOT NULL;

-- chat_id may already exist in metadata for some runs; promote to column
ALTER TABLE workflow_node_runs
  ADD COLUMN IF NOT EXISTS chat_id uuid REFERENCES chats(id) ON DELETE SET NULL;

// features/tasks/types.ts

export const TASK_TRIGGER_TYPES = [
  "manual",
  "entity_created",
  "entity_updated",
  "field_changed",
  "cron",
  "webhook",
] as const;
export type TaskTriggerType = (typeof TASK_TRIGGER_TYPES)[number];

export const TASK_STATUSES = ["draft", "active", "paused", "disabled", "completed"] as const;
export type TaskStatus = (typeof TASK_STATUSES)[number];

export interface TaskRecord {
  id: string;
  tenant_id: string;
  entity_type_id: string | null;
  entity_id: string | null;
  parent_id: string | null;
  depends_on: string[];
  sort_order: number;
  name: string;
  slug: string;
  description: string | null;
  instructions: string | null;
  completion_criteria: string | null;
  agent_slug: string | null;
  assigned_to: string | null;       // user UUID for human assignment
  trigger_type: TaskTriggerType;
  trigger_config: Record<string, unknown>;
  output_type: WorkflowOutputType | null;
  output_config: TaskOutputConfig;
  status: TaskStatus;
  is_system: boolean;
  last_run_at: string | null;
  last_run_status: string | null;
  run_count: number;
  metadata: TaskMetadata;
  created_by: string | null;
  created_at: string;
  updated_at: string;
}

export interface TaskOutputConfig {
  /** Field names this action writes to */
  fieldNames?: string[];
  /** Entity type slug for entity/relation-entity outputs */
  entityTypeSlug?: string;
  /** Extraction sources for agent context */
  sources?: ExtractionSource[];
}

export interface TaskMetadata {
  /** Max agent loop iterations (default: 10) */
  maxSteps?: number;
  /** JSON Schema for user input before manual trigger */
  inputSchema?: Record<string, unknown>;
  /** Consensus config (multi-agent) */
  consensus?: {
    agentSlugs: string[];
    strategy: "majority" | "unanimous" | "best-confidence";
  };
  /** Refinement loop config */
  refinement?: {
    enabled: boolean;
    judgeAgent?: string;
    maxIterations?: number;
    qualityThreshold?: number;
    refinementPrompt?: string;
  };
  /** For system extraction actions: original field config reference */
  fieldKey?: string;
  /** Requires human approval before output is promoted */
  requiresApproval?: boolean;
}

/** Resolved task tree for an entity — type-level + entity-level merged */
export interface TaskTree {
  roots: TaskNode[];
}

export interface TaskNode {
  task: TaskRecord;
  children: TaskNode[];
  lastRun?: {
    id: string;
    status: WorkflowNodeStatus;
    chat_id: string | null;
    completed_at: string | null;
  };
}

// features/tasks/server/resolve.ts

/**
 * Resolve all tasks for an entity, merging type-level and entity-level.
 * Returns a tree structure (parent/child) with last run status.
 */
export async function resolveTaskTree(
  tenantId: string,
  entityTypeId: string,
  entityId?: string,
): Promise<TaskTree> {
  // 1. Fetch all tasks for this entity type (where entity_id IS NULL)
  // 2. If entityId, also fetch entity-level tasks
  // 3. Entity-level tasks override type-level by slug
  // 4. Build tree from parent_id relationships
  // 5. For each leaf/node, fetch last workflow_node_run with task_id = task.id
  // 6. Return TaskTree with roots[] containing nested TaskNode[]
}

/**
 * Get claimable tasks for an agent — used by heartbeat.
 * Returns tasks where agent_slug matches or is null (unassigned).
 */
export async function getClaimableTasks(
  tenantId: string,
  agentSlug: string,
): Promise<TaskRecord[]> {
  // 1. Query tasks WHERE status = 'active'
  //    AND (agent_slug = agentSlug OR (agent_slug IS NULL AND assigned_to IS NULL))
  // 2. Check for pending workflow_node_runs linked to these tasks
  // 3. Check for tasks that should have been triggered but haven't
  // 4. Return sorted by priority (sort_order, then depends_on satisfaction)
}

/**
 * Get all tasks assigned to a user — used by task backlog views.
 */
export async function getUserTasks(
  tenantId: string,
  userId: string,
): Promise<TaskRecord[]> {
  // Query tasks WHERE assigned_to = userId AND status IN ('active', 'draft')
  // Include last run status
  // Order by sort_order, then created_at
}

/**
 * Get tenant-wide task backlog — unassigned tasks available to claim.
 */
export async function getTaskBacklog(
  tenantId: string,
): Promise<TaskRecord[]> {
  // Query tasks WHERE agent_slug IS NULL AND assigned_to IS NULL
  //   AND status = 'active'
  // Order by sort_order, then created_at
}

Task triggered
  ↓
Is this a parent task with subtasks?
  ├─ YES: Create workflow_run, seed workflow_node_runs per subtask
  │       (respecting depends_on for execution order)
  │       Execute using existing runEntityWorkflow() patterns
  │       Each subtask node gets its own chat for the conversation
  │
  └─ NO (leaf task): Create workflow_run + single workflow_node_run
                     Create chat for the run conversation
                     Execute agent with task.instructions (or wait for human)
                     Agent has entity context + tools
                     ↓
                     On completion: evaluate completion_criteria
                     ├─ Met: mark completed, write output per output_type
                     │       For one-off tasks: set task.status = 'completed'
                     └─ Not met: mark failed, task remains claimable
                         Run history preserved, linked via chat_id
                         Next claim gets context: "Previous attempt failed: [reason]"

// features/tasks/server/trigger.ts

export interface TriggerTaskInput {
  taskId: string;
  entityId?: string;          // required for type-level tasks, optional for standalone
  tenantId: string;
  triggeredBy: "manual" | "event" | "cron" | "heartbeat";
  userInput?: Record<string, unknown>;  // from inputSchema modal
}

export interface TriggerTaskResult {
  runId: string;
  chatId: string;             // every run is a chat conversation
  status: WorkflowRunStatus;
  nodeCount: number;
}

export async function triggerTask(
  input: TriggerTaskInput
): Promise<TriggerTaskResult> {
  // 1. Load task (+ entity + entity type if entity-scoped)
  // 2. If task has subtasks: load children, resolve depends_on
  // 3. Create workflow_run linked to task
  // 4. Create chat for the run (title: "{task.name}" or "{task.name} on {entity.title}")
  // 5. For each executable node (task or subtasks):
  //    a. Create workflow_node_run with task_id + chat_id
  //    b. Set status based on dependency satisfaction
  //    c. For human-assigned subtasks: set to waiting_human
  // 6. Execute using adapted runEntityWorkflow() patterns:
  //    - Resolve agent (task.agent_slug → parent → entity type default)
  //    - Build prompt from task.instructions with {field} substitution
  //    - Inject entity context + previous run history (if retry)
  //    - Execute via executeAgentSync() (background) or executeAgent() (manual)
  //    - Record messages to the run's chat
  // 7. On completion: evaluate completion_criteria if present
  //    - If criteria met: mark completed, write output
  //    - If criteria not met: mark failed with reason
  // 8. Update task.last_run_at, last_run_status, run_count
  // 9. For one-off tasks (no trigger_type event): set task.status = 'completed'
  // 10. Return result with chatId for user to inspect
}

// features/tasks/server/system-tasks.ts

export async function syncSystemTasks(
  tenantId: string,
  entityTypeId: string,
  fieldConfigs: Record<string, FieldConfig>,
  defaultAgentSlug?: string,
): Promise<void> {
  // 1. Upsert parent task:
  //    name: "Extract fields"
  //    slug: "extraction"
  //    trigger_type: "entity_created"
  //    is_system: true
  //
  // 2. For each field with extraction config:
  //    Upsert child task:
  //    name: "Extract {field.label || fieldKey}"
  //    slug: "extract-{fieldKey}"
  //    parent_id: extraction parent
  //    instructions: fieldConfig.extraction.instructions
  //    agent_slug: fieldConfig.extraction.agentSlug || defaultAgentSlug
  //    output_type: "field"
  //    output_config: { fieldNames: [fieldKey], sources: extraction.sources }
  //    depends_on: extraction.dependsOn (mapped to "extract-{dep}" slugs)
  //    metadata: { maxSteps, consensus, refinement, requiresApproval, fieldKey }
  //    is_system: true
  //
  // 3. For fields with humanInput: true:
  //    Upsert child task:
  //    slug: "input-{fieldKey}"
  //    assigned_to: null, agent_slug: null (human-assigned, appears in backlog)
  //    is_system: true
  //
  // 4. Remove system tasks for fields that no longer have extraction config
}

// features/workflows/compile.ts (updated)

export function compileTasksToWorkflow(
  tasks: TaskRecord[],
  parentTask: TaskRecord,
): WorkflowDefinition {
  // Convert task tree to WorkflowNodeDefinition[]
  // Each subtask → one node
  // depends_on → converted to node key dependencies
  // Output contracts from task.output_type + output_config
  // Consensus/refinement from task.metadata
}

// features/agents/lib/attention-context.ts (updated)

export async function buildAttentionSnapshot(admin, params) {
  // BEFORE: scan workflow_node_runs + agent-goal entities + agent-task entities
  // AFTER: scan tasks table

  // 1. Get claimable tasks for this agent
  const claimable = await getClaimableTasks(params.tenantId, params.agentSlug);

  // 2. Get in-progress runs for this agent
  const inProgress = await getInProgressRuns(params.tenantId, params.agentSlug);

  // 3. Get recently failed runs (available for retry)
  const failed = await getFailedRuns(params.tenantId, params.agentSlug);

  // 4. Build attention context:
  //    "Tasks available to claim:"
  //    - [Extract fields] on "Acme Corp" (Opportunity) — triggered by entity creation
  //    - [Generate social posts] on "Q4 Report" (Content Piece) — manual, unclaimed
  //
  //    "Tasks in progress:"
  //    - [Extract revenue] on "Acme Corp" — running (started 2 min ago)
  //
  //    "Tasks that failed (available for retry):"
  //    - [Extract website] on "Beta Inc" — failed 1 hour ago
  //      Previous attempt: could not find company website via web search
  //      Chat: /chat/abc123

  return { context, claimableCount, inProgressCount, failedCount };
}

// features/inngest/functions/task-dispatch.ts

export const taskDispatch = inngest.createFunction(
  { id: "task-dispatch", concurrency: { limit: 5 } },
  [
    { event: EVENT_NAMES.ENTITY_CREATED },
    { event: EVENT_NAMES.ENTITY_UPDATED },
  ],
  async ({ event, step }) => {
    // 1. Map event to trigger types:
    //    entity/created → ["entity_created"]
    //    entity/updated → ["entity_updated", "field_changed"]
    //
    // 2. Query tasks WHERE:
    //    tenant_id matches
    //    AND (entity_type_id matches OR entity_id matches)
    //    AND trigger_type IN (matched types)
    //    AND status = 'active'
    //
    // 3. For field_changed triggers: check trigger_config conditions
    //    against the event's changed fields
    //
    // 4. For each matching task: trigger via step.run()
    //    Reuse triggerTask() with triggeredBy: "event"
  }
);

// features/inngest/functions/task-cron.ts

export const taskCron = inngest.createFunction(
  { id: "task-cron" },
  { cron: "*/1 * * * *" },
  async ({ step }) => {
    // 1. Query tasks WHERE trigger_type = 'cron' AND status = 'active'
    // 2. Check schedule match via shouldRunNow()
    // 3. For entity-level actions: trigger for that entity
    // 4. For type-level actions: trigger once with type context
  }
);

// features/inngest/functions/entity-extraction.ts (modified)

// Before: always runs extraction if entity type has extractable fields
// After: checks if "extraction" system task exists and is active
//   If active → triggers via triggerTask()
//   If disabled/paused → skip (user has turned off extraction)
//   If no task exists → fall back to legacy behavior (transition period)

// features/blocks/definitions/tasks.ts

{
  type: "tasks",
  meta: {
    name: "Tasks",
    description: "Shows available tasks, run status, and history for an entity",
    icon: "Zap",
    category: "interactive",
  },
  configSchema: z.object({
    showSystem: z.boolean().default(true),
    showRunHistory: z.boolean().default(true),
    showChildren: z.boolean().default(true),
    layout: z.enum(["cards", "compact"]).default("cards"),
  }),
  dataRequirement: "entity-single",
  resolve: async (config, context) => {
    const tree = await resolveTaskTree(
      context.tenantId, context.entityTypeId, context.entityId
    );
    return { tree, entity: context.entity };
  },
}

┌─ Task Card ────────────────────────────────────────────────┐
│ ⚡ Generate social posts            [Active] [▶ Run Now]   │
│ Create FB, IG, and LinkedIn drafts from this content piece │
│ Trigger: manual · Agent: content-agent                     │
│ ├── Create FB draft          ✓ completed (2h ago)          │
│ ├── Create IG draft          ✓ completed (2h ago)          │
│ ├── Create LinkedIn draft    ✗ failed (1h ago) [View run]  │
│ └── Request approval         ○ blocked (depends on above)  │
│                                     Assigned to: Tyler      │
│                                                             │
│ Last run: 2 hours ago · Partial (3/4 completed)             │
│ [View conversation] [Re-run failed]                         │
└─────────────────────────────────────────────────────────────┘

// features/tools/admin/task-tools.ts

{
  slug: "manageTasks",
  name: "Manage Tasks",
  description: "Create, update, delete, list, or trigger tasks on entity types, entities, or standalone",
  category: "admin",
  groups: ["admin"],
  inputSchema: z.object({
    action: z.enum(["create", "update", "delete", "list", "trigger"]),

    // For create/update:
    entityTypeSlug: z.string().optional(),
    entityId: z.string().optional(),
    parentSlug: z.string().optional(),
    name: z.string().optional(),
    slug: z.string().optional(),
    instructions: z.string().optional(),
    completionCriteria: z.string().optional(),
    agentSlug: z.string().optional(),
    assignedTo: z.string().optional(),     // user ID for human assignment
    triggerType: TaskTriggerTypeSchema.optional(),
    triggerConfig: z.record(z.unknown()).optional(),
    outputType: WorkflowOutputTypeSchema.optional(),
    outputConfig: z.record(z.unknown()).optional(),
    status: TaskStatusSchema.optional(),
    dependsOn: z.array(z.string()).optional(),

    // For trigger:
    taskId: z.string().optional(),
    taskSlug: z.string().optional(),
    targetEntityId: z.string().optional(),

    // For list:
    // entityTypeSlug, entityId, agentSlug, or userId filter

    // For update/delete:
    id: z.string().optional(),
  }),
}

┌─ Tasks Tab ────────────────────────────────────────────────┐
│                                                             │
│  System Tasks                                               │
│  ┌────────────────────────────────────────────────────────┐│
│  │ ⚡ Extract fields   [Active ▾]  [🔒 System]            ││
│  │   Trigger: entity_created (auto-run)                   ││
│  │   6 subtasks (5 agent, 1 human)                        ││
│  │   [Expand ▾]                                           ││
│  │     · Extract summary (analyst) — writes: summary      ││
│  │     · Extract revenue (analyst) — writes: revenue      ││
│  │     · Extract market (analyst) — writes: market_size   ││
│  │     · Provide strategy — assigned to: Tyler            ││
│  │     · Extract recommendation (analyst) — depends on ↑  ││
│  │     · Score opportunity (analyst) — depends on all     ││
│  └────────────────────────────────────────────────────────┘│
│                                                             │
│  Custom Tasks                                               │
│  ┌────────────────────────────────────────────────────────┐│
│  │ 📝 Generate social posts  [Active ▾]  [Edit] [Delete]  ││
│  │   Trigger: manual · Agent: content-agent               ││
│  │   3 subtasks                                            ││
│  └────────────────────────────────────────────────────────┘│
│                                                             │
│  [+ Add task]                                               │
└─────────────────────────────────────────────────────────────┘

POST   /api/tasks                — Create task
GET    /api/tasks                — List tasks (query: entityTypeId, entityId, parentId, agentSlug, assignedTo, status)
PATCH  /api/tasks/[id]           — Update task
DELETE /api/tasks/[id]           — Delete task (blocks system tasks)
POST   /api/tasks/[id]/trigger   — Trigger task (creates run, returns chatId)
GET    /api/tasks/[id]/runs      — List runs for a task

┌─ Task Card ────────────────────────────────────────────────┐
│ ⚡ Generate social posts            [Active] [▶ Run Now]   │
│ Create FB, IG, and LinkedIn drafts from this content piece │
│ Trigger: manual · Agent: content-agent                     │
│                                                             │
│ Subtasks:                                                   │
│ ├── Create FB draft          ✓ completed (2h ago)          │
│ ├── Create IG draft          ✓ completed (2h ago)          │
│ ├── Create LinkedIn draft    ✗ failed (1h ago) [View run]  │
│ │                            Assigned to: content-agent     │
│ └── Request approval         ○ blocked                     │
│                              Assigned to: Tyler             │
│                                                             │
│ Last run: 2 hours ago · Partial (3/4)                       │
│ [View conversation] [Re-run failed]                         │
└─────────────────────────────────────────────────────────────┘

┌─ Tasks ────────────────────────────────────────────────────┐
│  System                                                     │
│  [TaskCard: Extract fields]                                 │
│                                                             │
│  Custom                                                     │
│  [TaskCard: Generate social posts]                          │
│  [TaskCard: Email prospects on publish]                     │
│                                                             │
│  [+ Add task]                                               │
└─────────────────────────────────────────────────────────────┘

┌─ Run History ──────────────────────────────────────────────┐
│  Run #3 · 2 hours ago · Partial (3/4)      [View chat →]  │
│  Run #2 · Yesterday · Failed               [View chat →]  │
│  Run #1 · 3 days ago · Completed           [View chat →]  │
└─────────────────────────────────────────────────────────────┘