// Schedule definition
type AutomationSchedule =
  | { kind: "at"; atMs: number }                                              // One-shot
  | { kind: "interval"; everyMs: number; jitterMs?: number }                  // Fixed interval
  | { kind: "cron"; expression: string; timezone?: string; staggerMs?: number } // Cron expression

// Execution mode
type AutomationExecution =
  | { kind: "isolated"; agentType: string; retentionMs?: number }
  | { kind: "session"; sessionId: string }

// Delivery configuration
type AutomationDelivery =
  | { kind: "inbox"; autoArchiveOnOk?: boolean; okMaxChars?: number }
  | { kind: "session"; sessionId: string }
  | { kind: "both"; sessionId: string; autoArchiveOnOk?: boolean; okMaxChars?: number }
  | { kind: "none" }

// Security profile for the run sandbox
type AutomationSecurityProfile = "restricted" | "networked" | "custom"

// Full automation definition (wire format)
interface AutomationDef {
  name: string
  description?: string
  schedule: AutomationSchedule
  execution: AutomationExecution
  prompt: string
  delivery: AutomationDelivery
  security?: {
    profile: AutomationSecurityProfile
    allowedDomains?: string[]          // Only for "networked" profile
    allowShell?: boolean               // Default: true
    maxEgressBytes?: number
  }
  timeoutMs?: number
  maxCostMicroDollars?: number
}

// Automation (server-managed, includes computed fields)
interface Automation extends AutomationDef {
  id: string
  enabled: boolean
  createdBy: { userId: string; email?: string }
  createdAtMs: number
  updatedAtMs: number
  lastRunAtMs?: number
  nextRunAtMs?: number
  consecutiveFailures: number
}

// Automation run
type RunStatus = "queued" | "running" | "waiting" | "success" | "error" | "skipped" | "canceled"
type InboxState = "unread" | "read" | "archived"

interface AutomationRun {
  id: string
  automationId: string
  status: RunStatus
  inboxState: InboxState
  pinned: boolean
  scheduledForMs: number
  startedAtMs?: number
  finishedAtMs?: number
  attempt: number
  summary?: string
  outputMarkdown?: string
  error?: { code: string; message: string }
  sessionId?: string
  turnId?: string
  triggerKind: "schedule" | "manual" | "catchup" | "wake"
}

// Heartbeat configuration
interface HeartbeatConfig {
  enabled: boolean
  intervalMs: number
  prompt?: string
  activeHours?: {
    start: string  // "HH:MM"
    end: string    // "HH:MM"
    timezone?: string
  }
  autoArchiveOnOk: boolean
  okMaxChars: number
}

CREATE TABLE IF NOT EXISTS automations (
  id TEXT PRIMARY KEY,
  name TEXT NOT NULL,
  description TEXT,
  enabled INTEGER NOT NULL DEFAULT 1 CHECK (enabled IN (0, 1)),

  -- Serialized JSON for flexible schedule/execution/delivery schemas
  schedule_json TEXT NOT NULL,
  execution_json TEXT NOT NULL,
  delivery_json TEXT NOT NULL,
  prompt TEXT NOT NULL,

  -- Security profile (JSON: profile, allowedDomains, allowShell, maxEgressBytes)
  security_json TEXT NOT NULL DEFAULT '{"profile":"restricted"}',

  -- Denormalized for efficient queries
  schedule_kind TEXT NOT NULL CHECK (schedule_kind IN ('at', 'interval', 'cron')),
  automation_kind TEXT NOT NULL DEFAULT 'cron' CHECK (automation_kind IN ('cron', 'heartbeat')),
  target_session_id TEXT,
  agent_type TEXT,

  -- Scheduling state
  next_run_at_ms INTEGER,
  last_run_at_ms INTEGER,
  last_run_status TEXT,
  consecutive_failures INTEGER NOT NULL DEFAULT 0,
  backoff_until_ms INTEGER,

  -- Budget controls
  timeout_ms INTEGER,
  max_cost_micro_dollars INTEGER,

  -- Audit
  created_by_user_id TEXT NOT NULL,
  created_by_email TEXT,
  created_at_ms INTEGER NOT NULL,
  updated_at_ms INTEGER NOT NULL,
  version INTEGER NOT NULL DEFAULT 0
);

-- Index for the scheduler: find due automations efficiently
CREATE INDEX IF NOT EXISTS idx_automations_due
  ON automations(next_run_at_ms)
  WHERE enabled = 1 AND next_run_at_ms IS NOT NULL;

-- Index for session-scoped lookups (heartbeat config, session automations)
CREATE INDEX IF NOT EXISTS idx_automations_session
  ON automations(target_session_id);

-- Enforce at most one active heartbeat per session
CREATE UNIQUE INDEX IF NOT EXISTS idx_heartbeat_unique_session
  ON automations(target_session_id)
  WHERE automation_kind = 'heartbeat' AND enabled = 1;

CREATE TABLE IF NOT EXISTS automation_runs (
  id TEXT PRIMARY KEY,
  automation_id TEXT NOT NULL REFERENCES automations(id) ON DELETE CASCADE,

  trigger_kind TEXT NOT NULL CHECK (trigger_kind IN ('schedule', 'manual', 'catchup', 'wake')),
  status TEXT NOT NULL CHECK (status IN ('queued', 'running', 'waiting', 'success', 'error', 'skipped', 'canceled')),
  attempt INTEGER NOT NULL DEFAULT 1,

  -- Inbox state
  inbox_state TEXT NOT NULL DEFAULT 'archived' CHECK (inbox_state IN ('unread', 'read', 'archived')),
  pinned INTEGER NOT NULL DEFAULT 0 CHECK (pinned IN (0, 1)),

  -- Timing
  scheduled_for_ms INTEGER NOT NULL,
  created_at_ms INTEGER NOT NULL,
  started_at_ms INTEGER,
  finished_at_ms INTEGER,

  -- Output
  summary TEXT,
  output_markdown TEXT,

  -- Error tracking
  error_code TEXT,
  error_message TEXT,

  -- Session correlation
  run_session_id TEXT,
  run_turn_id TEXT,

  -- Metadata (usage, questions, permissions — serialized JSON)
  metadata_json TEXT,

  UNIQUE (automation_id, scheduled_for_ms, trigger_kind)
);

-- Index for listing runs by automation
CREATE INDEX IF NOT EXISTS idx_runs_by_automation
  ON automation_runs(automation_id, scheduled_for_ms DESC);

-- Index for the triage inbox
CREATE INDEX IF NOT EXISTS idx_runs_inbox
  ON automation_runs(inbox_state, created_at_ms DESC)
  WHERE inbox_state != 'archived';

AppConfigLive
  │
  ├──→ AutomationStoreLive      (reads/writes automation + run tables)
  │       │
  ├──→ SessionRuntimeLive       (extracted: start turns without WebSocket client)
  │       │
  └──→ AutomationEngineLive     (scheduler fiber, executor, heartbeat runner)
          │
          ├── depends on: AutomationStore
          ├── depends on: SessionRuntime
          ├── depends on: Broadcaster
          └── depends on: AppConfig

export class AutomationStore extends Context.Tag("AutomationStore")<
  AutomationStore,
  {
    // Automation CRUD
    readonly list: (tenantId: string, includeDisabled?: boolean)
      => Effect.Effect<ReadonlyArray<Automation>, DbError>
    readonly get: (tenantId: string, id: string)
      => Effect.Effect<Automation, DbError | NotFound>
    readonly create: (tenantId: string, def: AutomationDef, createdBy: AuthIdentity)
      => Effect.Effect<Automation, DbError | ValidationError>
    readonly update: (tenantId: string, id: string, patch: Partial<AutomationDef>)
      => Effect.Effect<Automation, DbError | NotFound | ValidationError>
    readonly remove: (tenantId: string, id: string)
      => Effect.Effect<void, DbError | NotFound>
    readonly setEnabled: (tenantId: string, id: string, enabled: boolean)
      => Effect.Effect<Automation, DbError | NotFound>

    // Scheduler queries
    readonly nextDue: (tenantId: string, nowMs: number, limit: number)
      => Effect.Effect<ReadonlyArray<Automation>, DbError>
    readonly claimRun: (tenantId: string, automationId: string, nowMs: number)
      => Effect.Effect<AutomationRun, DbError>
    readonly completeRun: (tenantId: string, runId: string, outcome: RunOutcome)
      => Effect.Effect<void, DbError>
    readonly advanceSchedule: (tenantId: string, automationId: string, nowMs: number)
      => Effect.Effect<void, DbError>

    // Run queries
    readonly listRuns: (tenantId: string, automationId: string, limit: number, cursor?: string)
      => Effect.Effect<ReadonlyArray<AutomationRun>, DbError>

    // Inbox queries
    readonly listInbox: (tenantId: string, filter: InboxFilter, limit: number, cursor?: string)
      => Effect.Effect<ReadonlyArray<AutomationRun>, DbError>
    readonly updateInboxItem: (tenantId: string, runId: string, patch: InboxPatch)
      => Effect.Effect<void, DbError | NotFound>
  }
>() {}

export class SessionRuntime extends Context.Tag("SessionRuntime")<
  SessionRuntime,
  {
    // Start a turn and return a handle for observing completion
    readonly startTurn: (params: {
      sessionId: string
      tenantId: string
      agentType: string
      text: string
      metadata?: Record<string, unknown>
    }) => Effect.Effect<TurnHandle, SessionError | PodiumConnectionError>

    // Ensure a session exists and has an active agent connection
    readonly ensureActive: (params: {
      sessionId: string
      tenantId: string
      agentType: string
    }) => Effect.Effect<void, SessionError | PodiumConnectionError>
  }
>() {}

// A turn handle provides a Deferred that resolves on completion
interface TurnHandle {
  readonly turnId: string
  readonly sessionId: string
  readonly completion: Deferred.Deferred<TurnOutcome, never>
}

type TurnOutcome =
  | { kind: "complete"; finalText: string; usage?: UsageRecord }
  | { kind: "error"; code: string; message: string }
  | { kind: "stopped" }

export class AutomationEngine extends Context.Tag("AutomationEngine")<
  AutomationEngine,
  {
    // Signal the scheduler to recompute next due time for a tenant
    readonly reschedule: (tenantId: string) => Effect.Effect<void>

    // Execute a run immediately (manual trigger)
    readonly runNow: (tenantId: string, automationId: string)
      => Effect.Effect<AutomationRun, EngineError>

    // Wake a heartbeat runner
    readonly wakeHeartbeat: (tenantId: string, sessionId: string, reason: string)
      => Effect.Effect<void, NotFound>
  }
>() {}

┌─ Per-Tenant Scheduler Fiber ──────────────────────────────┐
│                                                            │
│  loop:                                                     │
│    1. Query: nextDue(tenantId, now, batchSize)             │
│    2. Compute sleepDuration = min(nextRunAtMs) - now       │
│    3. Race:                                                │
│       a) Effect.sleep(sleepDuration)                       │
│       b) Queue.take(rescheduleQueue)   ← wake signal       │
│    4. If woken by (a): claim + execute due automations     │
│       If woken by (b): re-query (schedule changed)         │
│    5. After execution: advanceSchedule, loop               │
│                                                            │
└────────────────────────────────────────────────────────────┘

import { Cron } from "effect"

// Validate a cron expression at automation creation time
const validated = Cron.parse("0 9 * * 1-5")  // Either<ParseError, Cron>

// Compute next run time
const nextRun = Cron.next(cron, { after: new Date() })

// Optional deterministic stagger to spread load
const stagger = hash(automationId) % (staggerMs ?? 0)
const nextRunMs = nextRun.getTime() + stagger

// Heartbeat config maps to AutomationDef with constraints:
{
  schedule: { kind: "interval", everyMs: 1_800_000 },  // 30 minutes default
  execution: { kind: "session", sessionId: targetSessionId },
  delivery: { kind: "inbox", autoArchiveOnOk: true, okMaxChars: 300 },
  prompt: "Check if anything needs attention. If not, reply with OK.",
  // Extended fields stored in schedule_json:
  activeHours: { start: "09:00", end: "22:00", timezone: "America/New_York" }
}

const runRetry = Schedule.exponential("500 millis").pipe(
  Schedule.jittered,
  Schedule.compose(Schedule.recurs(3))
)

Container filesystem:
  /workspace/          <- Chronicle workspace for this tenant+session (bind mount)
  /tmp/                <- Ephemeral scratch space (tmpfs, size-limited)
  /                    <- Read-only base image (agent runtime, tools)

NOT mounted (invisible to agent):
  /data/tenants/       <- Gateway control-plane SQLite databases
  /data/sessions/      <- Other sessions' databases
  Other tenants' Chronicle workspace directories
  Gateway process files, config, secrets

// AutomationEngine passes security context to Podium
yield* sessionRuntime.startTurn({
  sessionId: runSessionId,
  tenantId: identity.tenantId,
  agentType: automation.agentType,
  text: automation.prompt,
  metadata: {
    automationId: automation.id,
    runId: run.id,
    securityProfile: automation.security?.profile ?? "restricted",
    isUnattended: true,
  }
})

interface AutomationSecurityPolicy {
  profile: "restricted" | "networked" | "custom"

  filesystem: {
    readOnlyPaths?: string[]     // Paths within /workspace that are read-only
    denyPatterns?: string[]      // Glob patterns to block (e.g., "**/*.db")
  }

  network: {
    mode: "none" | "proxy"
    allowedDomains?: string[]    // For proxy mode
    maxRequests?: number
    maxEgressBytes?: number
  }

  resources: {
    timeoutMs: number
    cpuMillis?: number
    memoryMb?: number
    diskMb?: number
  }
}

📋 Sessions
   Session 1
   Session 2
   ...
⚡ Automations
   📥 Triage (3 unread)
   📋 All Automations

User: "Every morning at 9am, check if any PRs need my review
       and only tell me if there are any"

→ The agent (or gateway directly) parses this into a draft:

  ┌──────────────────────────────────────┐
  │ ⚡ New Automation                     │
  │                                       │
  │ 📅 Daily at 9:00 AM EST              │
  │ 📁 diminuendo (current project)       │
  │                                       │
  │ "Check if any GitHub PRs need my      │
  │  review. If none, reply OK."          │
  │                                       │
  │  [Create]  [Edit]  [Cancel]           │
  └──────────────────────────────────────┘

→ User clicks Create. Done.

User: "Keep an eye on this project and let me know if anything needs attention"

→ System enables heartbeat for the current project:

  ┌──────────────────────────────────────┐
  │ 💓 Heartbeat Enabled                  │
  │                                       │
  │ 📁 diminuendo                         │
  │ ⏱️ Every 30 minutes (9am-10pm EST)    │
  │                                       │
  │ I'll check in periodically and only   │
  │ notify you if something needs your    │
  │ attention.                            │
  │                                       │
  │  [OK]  [Adjust Settings]              │
  └──────────────────────────────────────┘

// New layers
const AutomationStoreLayer = AutomationStoreLive.pipe(
  Layer.provide(Layer.mergeAll(AppConfigLive, WorkerLayer))
)
const SessionRuntimeLayer = SessionRuntimeLive.pipe(
  Layer.provide(RouterDeps)
)
const AutomationEngineLayer = AutomationEngineLive.pipe(
  Layer.provide(Layer.mergeAll(
    AutomationStoreLayer, SessionRuntimeLayer, BroadcastLayer, AppConfigLive
  ))
)

// Add to RouterDeps so protocol handlers can access
const RouterDeps = Layer.mergeAll(
  RegistryLayer, PodiumLayer, AppConfigLive, BroadcastLayer,
  BillingLayer, WorkerLayer, MembershipLayer,
  AutomationStoreLayer, AutomationEngineLayer, SessionRuntimeLayer,
)

readonly tenantAutomationsEvent: (tenantId: string, event: unknown) => Effect.Effect<void>
readonly tenantInboxEvent: (tenantId: string, event: unknown) => Effect.Effect<void>

Podium Agent → PodiumEventMapper → Handler Dispatch → Broadcaster