thinkwork-cli 0.12.12 → 0.12.15

package/dist/drizzle/0046_tenant_mcp_context_tools.sql

@@ -0,0 +1,26 @@
+-- creates: public.tenant_mcp_context_tools
+CREATE TABLE IF NOT EXISTS "tenant_mcp_context_tools" (
+  "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  "tenant_id" uuid NOT NULL REFERENCES "tenants"("id"),
+  "mcp_server_id" uuid NOT NULL REFERENCES "tenant_mcp_servers"("id"),
+  "tool_name" text NOT NULL,
+  "display_name" text,
+  "declared_read_only" boolean NOT NULL DEFAULT false,
+  "declared_search_safe" boolean NOT NULL DEFAULT false,
+  "approved" boolean NOT NULL DEFAULT false,
+  "default_enabled" boolean NOT NULL DEFAULT false,
+  "approved_by" uuid,
+  "approved_at" timestamp with time zone,
+  "metadata" jsonb,
+  "created_at" timestamp with time zone NOT NULL DEFAULT now(),
+  "updated_at" timestamp with time zone NOT NULL DEFAULT now()
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS "uq_tenant_mcp_context_tools_tool"
+  ON "tenant_mcp_context_tools" ("tenant_id", "mcp_server_id", "tool_name");
+
+CREATE INDEX IF NOT EXISTS "idx_tenant_mcp_context_tools_tenant"
+  ON "tenant_mcp_context_tools" ("tenant_id");
+
+CREATE INDEX IF NOT EXISTS "idx_tenant_mcp_context_tools_server"
+  ON "tenant_mcp_context_tools" ("mcp_server_id");

package/dist/drizzle/0047_add_context_engine_template_config.sql

@@ -0,0 +1,7 @@
+-- creates-column: public.agent_templates.context_engine
+ALTER TABLE public.agent_templates
+  ADD COLUMN IF NOT EXISTS "context_engine" jsonb DEFAULT '{"enabled": true}'::jsonb;
+
+UPDATE public.agent_templates
+SET "context_engine" = '{"enabled": true}'::jsonb
+WHERE "context_engine" IS NULL;

package/dist/drizzle/0048_tenant_context_provider_settings.sql

@@ -0,0 +1,22 @@
+-- creates: public.tenant_context_provider_settings
+CREATE TABLE IF NOT EXISTS "tenant_context_provider_settings" (
+  "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  "tenant_id" uuid NOT NULL REFERENCES "tenants"("id"),
+  "provider_id" text NOT NULL,
+  "family" text NOT NULL,
+  "enabled" boolean DEFAULT true NOT NULL,
+  "default_enabled" boolean DEFAULT false NOT NULL,
+  "config" jsonb DEFAULT '{}'::jsonb NOT NULL,
+  "last_tested_at" timestamp with time zone,
+  "last_test_state" text,
+  "last_test_latency_ms" integer,
+  "last_test_error" text,
+  "created_at" timestamp with time zone DEFAULT now() NOT NULL,
+  "updated_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS "uq_tenant_context_provider_settings_provider"
+  ON "tenant_context_provider_settings" ("tenant_id", "provider_id");
+
+CREATE INDEX IF NOT EXISTS "idx_tenant_context_provider_settings_tenant"
+  ON "tenant_context_provider_settings" ("tenant_id");

package/dist/drizzle/0050_brain_v0_entity_subtype.sql

@@ -0,0 +1,29 @@
+-- Brain v0 entity subtype foundation.
+--
+-- Plan:
+--   docs/plans/2026-04-29-004-feat-company-brain-v0-plan.md
+--
+-- Apply manually:
+--   psql "$DATABASE_URL" -f packages/database-pg/drizzle/0050_brain_v0_entity_subtype.sql
+--
+-- Column path updated post-0089 (wiki schema extraction renamed parent table to wiki.pages).
+-- creates-column: wiki.pages.entity_subtype
+
+\set ON_ERROR_STOP on
+
+BEGIN;
+
+SET LOCAL lock_timeout = '5s';
+SET LOCAL statement_timeout = '120s';
+
+ALTER TABLE public.wiki_pages
+  ADD COLUMN IF NOT EXISTS entity_subtype text;
+
+CREATE INDEX IF NOT EXISTS idx_wiki_pages_entity_subtype
+  ON public.wiki_pages (entity_subtype)
+  WHERE entity_subtype IS NOT NULL;
+
+COMMENT ON COLUMN public.wiki_pages.entity_subtype
+  IS 'brain-v0: docs/plans/2026-04-29-004-feat-company-brain-v0-plan.md';
+
+COMMIT;

package/dist/drizzle/0051_brain_v0_tenant_entity_pages.sql

@@ -0,0 +1,170 @@
+-- Brain v0 tenant-shared entity pages.
+--
+-- Plan:
+--   docs/plans/2026-04-29-004-feat-company-brain-v0-plan.md
+--
+-- Apply manually:
+--   psql "$DATABASE_URL" -f packages/database-pg/drizzle/0051_brain_v0_tenant_entity_pages.sql
+--
+-- creates: public.tenant_entity_pages
+-- creates: public.tenant_entity_page_sections
+-- creates: public.tenant_entity_page_links
+-- creates: public.tenant_entity_page_aliases
+-- creates: public.tenant_entity_section_sources
+-- creates: public.uq_tenant_entity_pages_tenant_type_subtype_slug
+-- creates: public.idx_tenant_entity_pages_search_tsv
+-- creates: public.uq_tenant_entity_section_sources_section_kind_ref
+-- creates-function: public.enforce_tenant_entity_section_source_tenant
+-- creates-trigger: public.tenant_entity_section_sources.trg_tenant_entity_section_sources_tenant
+
+\set ON_ERROR_STOP on
+
+BEGIN;
+
+SET LOCAL lock_timeout = '5s';
+SET LOCAL statement_timeout = '120s';
+
+CREATE EXTENSION IF NOT EXISTS pg_trgm;
+
+CREATE TABLE IF NOT EXISTS public.tenant_entity_pages (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  tenant_id uuid NOT NULL REFERENCES public.tenants(id) ON DELETE CASCADE,
+  type text NOT NULL,
+  entity_subtype text NOT NULL,
+  slug text NOT NULL,
+  title text NOT NULL,
+  summary text,
+  body_md text,
+  search_tsv tsvector GENERATED ALWAYS AS (
+    to_tsvector(
+      'english'::regconfig,
+      regexp_replace(coalesce(title, '') || ' ' || coalesce(summary, '') || ' ' || coalesce(body_md, ''), '[^[:alnum:]]+', ' ', 'g')
+    )
+  ) STORED,
+  status text DEFAULT 'active' NOT NULL,
+  parent_page_id uuid REFERENCES public.tenant_entity_pages(id) ON DELETE SET NULL,
+  hubness_score integer DEFAULT 0 NOT NULL,
+  tags text[] DEFAULT ARRAY[]::text[] NOT NULL,
+  last_compiled_at timestamp with time zone,
+  created_at timestamp with time zone DEFAULT now() NOT NULL,
+  updated_at timestamp with time zone DEFAULT now() NOT NULL,
+  CONSTRAINT tenant_entity_pages_type_allowed CHECK (type IN ('entity','topic','decision')),
+  CONSTRAINT tenant_entity_pages_entity_subtype_allowed CHECK (entity_subtype IN ('customer','opportunity','order','person'))
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS uq_tenant_entity_pages_tenant_type_subtype_slug
+  ON public.tenant_entity_pages (tenant_id, type, entity_subtype, slug);
+CREATE INDEX IF NOT EXISTS idx_tenant_entity_pages_tenant_type_status
+  ON public.tenant_entity_pages (tenant_id, type, status);
+CREATE INDEX IF NOT EXISTS idx_tenant_entity_pages_subtype
+  ON public.tenant_entity_pages (entity_subtype);
+CREATE INDEX IF NOT EXISTS idx_tenant_entity_pages_last_compiled
+  ON public.tenant_entity_pages (last_compiled_at);
+CREATE INDEX IF NOT EXISTS idx_tenant_entity_pages_search_tsv
+  ON public.tenant_entity_pages USING gin (search_tsv);
+CREATE INDEX IF NOT EXISTS idx_tenant_entity_pages_parent
+  ON public.tenant_entity_pages (parent_page_id);
+CREATE INDEX IF NOT EXISTS idx_tenant_entity_pages_title_trgm
+  ON public.tenant_entity_pages USING gin (title gin_trgm_ops);
+
+CREATE TABLE IF NOT EXISTS public.tenant_entity_page_sections (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  page_id uuid NOT NULL REFERENCES public.tenant_entity_pages(id) ON DELETE CASCADE,
+  section_slug text NOT NULL,
+  heading text NOT NULL,
+  body_md text NOT NULL,
+  position integer NOT NULL,
+  last_source_at timestamp with time zone,
+  aggregation jsonb,
+  status text DEFAULT 'active' NOT NULL,
+  created_at timestamp with time zone DEFAULT now() NOT NULL,
+  updated_at timestamp with time zone DEFAULT now() NOT NULL,
+  CONSTRAINT tenant_entity_page_sections_facet_type_allowed
+    CHECK (aggregation->>'facet_type' IS NULL OR aggregation->>'facet_type' IN ('operational','relationship','activity','compiled','kb_sourced','external'))
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS uq_tenant_entity_page_sections_page_slug
+  ON public.tenant_entity_page_sections (page_id, section_slug);
+CREATE INDEX IF NOT EXISTS idx_tenant_entity_page_sections_page_position
+  ON public.tenant_entity_page_sections (page_id, position);
+
+CREATE TABLE IF NOT EXISTS public.tenant_entity_page_links (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  from_page_id uuid NOT NULL REFERENCES public.tenant_entity_pages(id) ON DELETE CASCADE,
+  to_page_id uuid NOT NULL REFERENCES public.tenant_entity_pages(id) ON DELETE CASCADE,
+  kind text DEFAULT 'reference' NOT NULL,
+  context text,
+  created_at timestamp with time zone DEFAULT now() NOT NULL
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS uq_tenant_entity_page_links_from_to_kind
+  ON public.tenant_entity_page_links (from_page_id, to_page_id, kind);
+CREATE INDEX IF NOT EXISTS idx_tenant_entity_page_links_to
+  ON public.tenant_entity_page_links (to_page_id);
+CREATE INDEX IF NOT EXISTS idx_tenant_entity_page_links_kind
+  ON public.tenant_entity_page_links (kind);
+
+CREATE TABLE IF NOT EXISTS public.tenant_entity_page_aliases (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  page_id uuid NOT NULL REFERENCES public.tenant_entity_pages(id) ON DELETE CASCADE,
+  alias text NOT NULL,
+  source text NOT NULL,
+  created_at timestamp with time zone DEFAULT now() NOT NULL
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS uq_tenant_entity_page_aliases_page_alias
+  ON public.tenant_entity_page_aliases (page_id, alias);
+CREATE INDEX IF NOT EXISTS idx_tenant_entity_page_aliases_alias
+  ON public.tenant_entity_page_aliases (alias);
+CREATE INDEX IF NOT EXISTS idx_tenant_entity_page_aliases_alias_trgm
+  ON public.tenant_entity_page_aliases USING gin (alias gin_trgm_ops);
+
+CREATE TABLE IF NOT EXISTS public.tenant_entity_section_sources (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  tenant_id uuid NOT NULL REFERENCES public.tenants(id) ON DELETE CASCADE,
+  section_id uuid NOT NULL REFERENCES public.tenant_entity_page_sections(id) ON DELETE RESTRICT,
+  source_kind text NOT NULL,
+  source_ref text NOT NULL,
+  first_seen_at timestamp with time zone DEFAULT now() NOT NULL
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS uq_tenant_entity_section_sources_section_kind_ref
+  ON public.tenant_entity_section_sources (section_id, source_kind, source_ref);
+CREATE INDEX IF NOT EXISTS idx_tenant_entity_section_sources_tenant_kind_ref
+  ON public.tenant_entity_section_sources (tenant_id, source_kind, source_ref);
+
+CREATE OR REPLACE FUNCTION public.enforce_tenant_entity_section_source_tenant()
+RETURNS trigger
+LANGUAGE plpgsql
+AS $$
+DECLARE
+  parent_tenant_id uuid;
+BEGIN
+  SELECT p.tenant_id
+  INTO parent_tenant_id
+  FROM public.tenant_entity_page_sections s
+  INNER JOIN public.tenant_entity_pages p ON p.id = s.page_id
+  WHERE s.id = NEW.section_id;
+
+  IF parent_tenant_id IS NULL OR parent_tenant_id <> NEW.tenant_id THEN
+    RAISE EXCEPTION 'tenant_entity_section_sources tenant_id must match parent page tenant_id';
+  END IF;
+
+  RETURN NEW;
+END;
+$$;
+
+DROP TRIGGER IF EXISTS trg_tenant_entity_section_sources_tenant
+  ON public.tenant_entity_section_sources;
+CREATE TRIGGER trg_tenant_entity_section_sources_tenant
+  BEFORE INSERT OR UPDATE ON public.tenant_entity_section_sources
+  FOR EACH ROW
+  EXECUTE FUNCTION public.enforce_tenant_entity_section_source_tenant();
+
+COMMENT ON TABLE public.tenant_entity_pages IS 'brain-v0: docs/plans/2026-04-29-004-feat-company-brain-v0-plan.md';
+COMMENT ON TABLE public.tenant_entity_page_sections IS 'brain-v0: docs/plans/2026-04-29-004-feat-company-brain-v0-plan.md';
+COMMENT ON TABLE public.tenant_entity_page_links IS 'brain-v0: docs/plans/2026-04-29-004-feat-company-brain-v0-plan.md';
+COMMENT ON TABLE public.tenant_entity_page_aliases IS 'brain-v0: docs/plans/2026-04-29-004-feat-company-brain-v0-plan.md';
+COMMENT ON TABLE public.tenant_entity_section_sources IS 'brain-v0: docs/plans/2026-04-29-004-feat-company-brain-v0-plan.md';
+
+COMMIT;

package/dist/drizzle/0052_brain_v0_external_refs.sql

@@ -0,0 +1,41 @@
+-- Brain v0 operational snapshot cache for tenant entities.
+--
+-- Plan:
+--   docs/plans/2026-04-29-004-feat-company-brain-v0-plan.md
+--
+-- Apply manually:
+--   psql "$DATABASE_URL" -f packages/database-pg/drizzle/0052_brain_v0_external_refs.sql
+--
+-- creates: public.tenant_entity_external_refs
+
+\set ON_ERROR_STOP on
+
+BEGIN;
+
+SET LOCAL lock_timeout = '5s';
+SET LOCAL statement_timeout = '120s';
+
+CREATE TABLE IF NOT EXISTS public.tenant_entity_external_refs (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  tenant_id uuid NOT NULL REFERENCES public.tenants(id) ON DELETE CASCADE,
+  source_kind text NOT NULL,
+  external_id text,
+  source_payload jsonb,
+  as_of timestamp with time zone NOT NULL,
+  ttl_seconds integer NOT NULL,
+  created_at timestamp with time zone DEFAULT now() NOT NULL,
+  updated_at timestamp with time zone DEFAULT now() NOT NULL,
+  CONSTRAINT tenant_entity_external_refs_kind_allowed
+    CHECK (source_kind IN ('erp_customer','crm_opportunity','erp_order','crm_person','support_case','bedrock_kb')),
+  CONSTRAINT tenant_entity_external_refs_ttl_positive CHECK (ttl_seconds > 0)
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS uq_tenant_entity_external_refs_source
+  ON public.tenant_entity_external_refs (tenant_id, source_kind, external_id)
+  WHERE external_id IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_tenant_entity_external_refs_tenant_source
+  ON public.tenant_entity_external_refs (tenant_id, source_kind);
+
+COMMENT ON TABLE public.tenant_entity_external_refs IS 'brain-v0: docs/plans/2026-04-29-004-feat-company-brain-v0-plan.md';
+
+COMMIT;

package/dist/drizzle/0053_brain_v0_unresolved_mentions_subtype.sql

@@ -0,0 +1,48 @@
+-- Brain v0 subtype suggestion for unresolved mentions.
+--
+-- Plan:
+--   docs/plans/2026-04-29-004-feat-company-brain-v0-plan.md
+--
+-- Apply manually:
+--   psql "$DATABASE_URL" -f packages/database-pg/drizzle/0053_brain_v0_unresolved_mentions_subtype.sql
+--
+-- creates-column: wiki.unresolved_mentions.entity_subtype
+-- creates-constraint: wiki.unresolved_mentions.unresolved_mentions_entity_subtype_allowed
+-- Note: column + constraint were originally created on public.wiki_unresolved_mentions;
+-- 0089_wiki_schema_extraction.sql moved the table to wiki.unresolved_mentions and renamed
+-- the constraint. Markers updated to track post-0089 location so the drift reporter resolves
+-- them via pg_class/pg_constraint in the new schema.
+
+\set ON_ERROR_STOP on
+
+BEGIN;
+
+SET LOCAL lock_timeout = '5s';
+SET LOCAL statement_timeout = '120s';
+
+DO $$
+BEGIN
+  IF to_regclass('public.tenant_entity_pages') IS NULL THEN
+    RAISE EXCEPTION '0053 requires public.tenant_entity_pages from 0051';
+  END IF;
+END $$;
+
+ALTER TABLE public.wiki_unresolved_mentions
+  ADD COLUMN IF NOT EXISTS entity_subtype text;
+
+DO $$
+BEGIN
+  IF NOT EXISTS (
+    SELECT 1 FROM pg_constraint
+    WHERE conname = 'wiki_unresolved_mentions_entity_subtype_allowed'
+  ) THEN
+    ALTER TABLE public.wiki_unresolved_mentions
+      ADD CONSTRAINT wiki_unresolved_mentions_entity_subtype_allowed
+      CHECK (entity_subtype IS NULL OR entity_subtype IN ('customer','opportunity','order','person','concept','reflection'));
+  END IF;
+END $$;
+
+COMMENT ON COLUMN public.wiki_unresolved_mentions.entity_subtype
+  IS 'brain-v0: docs/plans/2026-04-29-004-feat-company-brain-v0-plan.md';
+
+COMMIT;

package/dist/drizzle/0054_wiki_compile_jobs_input.sql

@@ -0,0 +1,28 @@
+-- Add `input` jsonb column to wiki_compile_jobs.
+--
+-- Drives per-trigger input payloads on top of the shared compile job ledger.
+-- The first consumer is `trigger='enrichment_draft'` jobs, which carry
+-- { pageId, pageTable, candidates } so the draft-compile module can run
+-- against an explicit page and a synthesized candidate list rather than
+-- the cluster-driven input the default compile reads from.
+--
+-- Plan:
+--   docs/plans/2026-05-01-002-feat-brain-enrichment-draft-page-review-plan.md
+--
+-- Apply manually:
+--   psql "$DATABASE_URL" -f packages/database-pg/drizzle/0054_wiki_compile_jobs_input.sql
+--
+-- Column path updated post-0089 (wiki schema extraction renamed parent table to wiki.compile_jobs).
+-- creates-column: wiki.compile_jobs.input
+
+\set ON_ERROR_STOP on
+
+BEGIN;
+
+SET LOCAL lock_timeout = '5s';
+SET LOCAL statement_timeout = '120s';
+
+ALTER TABLE wiki_compile_jobs
+  ADD COLUMN IF NOT EXISTS input jsonb;
+
+COMMIT;

package/dist/drizzle/0055_routines_stepfunctions_substrate.sql

@@ -0,0 +1,202 @@
+-- Routines Step Functions substrate.
+--
+-- Adds the four new tables that back the Step Functions Routines runtime:
+--   * routine_executions       — execution-level state, mirrors SFN
+--   * routine_step_events      — per-step events (high-volume append)
+--   * routine_asl_versions     — published ASL snapshots for query/audit
+--   * routine_approval_tokens  — HITL task tokens with consume-once flag
+--
+-- And extends `routines` with the engine partition + Step-Functions-specific
+-- columns (state_machine_arn, alias_arn, documentation_md, current_version).
+-- Existing routine rows default to engine='legacy_python' so the new query
+-- paths can filter without a join.
+--
+-- Plan:
+--   docs/plans/2026-05-01-004-feat-routines-phase-a-substrate-plan.md
+--
+-- Apply manually:
+--   psql "$DATABASE_URL" -f packages/database-pg/drizzle/0055_routines_stepfunctions_substrate.sql
+--
+-- creates: public.routine_executions
+-- creates: public.routine_step_events
+-- creates: public.routine_asl_versions
+-- creates: public.routine_approval_tokens
+-- creates-column: public.routines.engine
+-- creates-column: public.routines.state_machine_arn
+-- creates-column: public.routines.state_machine_alias_arn
+-- creates-column: public.routines.documentation_md
+-- creates-column: public.routines.current_version
+-- creates-constraint: public.routines.routines_engine_enum
+-- creates: public.idx_routine_executions_sfn_arn
+-- creates: public.idx_routine_executions_tenant_status
+-- creates: public.idx_routine_executions_routine_started
+-- creates: public.idx_routine_executions_tenant_started
+-- creates: public.idx_routine_step_events_execution
+-- creates: public.idx_routine_step_events_tenant_recipe
+-- creates: public.idx_routine_step_events_python_dashboard
+-- creates: public.idx_routine_asl_versions_routine_version
+-- creates: public.idx_routine_asl_versions_tenant_routine
+-- creates: public.idx_routine_approval_tokens_inbox
+-- creates: public.idx_routine_approval_tokens_pending
+-- creates: public.idx_routine_approval_tokens_tenant_consumed
+-- creates: public.idx_routines_engine
+
+\set ON_ERROR_STOP on
+
+BEGIN;
+
+SET LOCAL lock_timeout = '5s';
+SET LOCAL statement_timeout = '120s';
+
+-- ---------------------------------------------------------------------------
+-- routines: engine partition + Step Functions resource columns
+-- ---------------------------------------------------------------------------
+
+ALTER TABLE public.routines
+  ADD COLUMN IF NOT EXISTS engine text NOT NULL DEFAULT 'legacy_python',
+  ADD COLUMN IF NOT EXISTS state_machine_arn text,
+  ADD COLUMN IF NOT EXISTS state_machine_alias_arn text,
+  ADD COLUMN IF NOT EXISTS documentation_md text,
+  ADD COLUMN IF NOT EXISTS current_version integer;
+
+ALTER TABLE public.routines
+  DROP CONSTRAINT IF EXISTS routines_engine_enum;
+
+ALTER TABLE public.routines
+  ADD CONSTRAINT routines_engine_enum
+  CHECK (engine IN ('legacy_python', 'step_functions'));
+
+CREATE INDEX IF NOT EXISTS idx_routines_engine
+  ON public.routines (engine);
+
+-- ---------------------------------------------------------------------------
+-- routine_executions
+-- ---------------------------------------------------------------------------
+
+CREATE TABLE IF NOT EXISTS public.routine_executions (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  tenant_id uuid NOT NULL REFERENCES public.tenants(id),
+  routine_id uuid NOT NULL REFERENCES public.routines(id),
+  state_machine_arn text NOT NULL,
+  alias_arn text,
+  version_arn text,
+  sfn_execution_arn text NOT NULL,
+  trigger_id uuid REFERENCES public.scheduled_jobs(id),
+  trigger_source text NOT NULL,
+  input_json jsonb,
+  output_json jsonb,
+  status text NOT NULL DEFAULT 'running',
+  started_at timestamp with time zone,
+  finished_at timestamp with time zone,
+  error_code text,
+  error_message text,
+  total_llm_cost_usd_cents bigint,
+  created_at timestamp with time zone NOT NULL DEFAULT now()
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_routine_executions_sfn_arn
+  ON public.routine_executions (sfn_execution_arn);
+CREATE INDEX IF NOT EXISTS idx_routine_executions_tenant_status
+  ON public.routine_executions (tenant_id, status);
+CREATE INDEX IF NOT EXISTS idx_routine_executions_routine_started
+  ON public.routine_executions (routine_id, started_at);
+CREATE INDEX IF NOT EXISTS idx_routine_executions_tenant_started
+  ON public.routine_executions (tenant_id, started_at);
+
+-- ---------------------------------------------------------------------------
+-- routine_step_events
+-- ---------------------------------------------------------------------------
+
+CREATE TABLE IF NOT EXISTS public.routine_step_events (
+  id bigserial PRIMARY KEY NOT NULL,
+  tenant_id uuid NOT NULL REFERENCES public.tenants(id),
+  execution_id uuid NOT NULL REFERENCES public.routine_executions(id),
+  node_id text NOT NULL,
+  recipe_type text NOT NULL,
+  status text NOT NULL,
+  started_at timestamp with time zone,
+  finished_at timestamp with time zone,
+  input_json jsonb,
+  output_json jsonb,
+  error_json jsonb,
+  llm_cost_usd_cents bigint,
+  retry_count integer NOT NULL DEFAULT 0,
+  stdout_s3_uri text,
+  stderr_s3_uri text,
+  stdout_preview text,
+  truncated boolean NOT NULL DEFAULT false,
+  created_at timestamp with time zone NOT NULL DEFAULT now()
+);
+
+CREATE INDEX IF NOT EXISTS idx_routine_step_events_execution
+  ON public.routine_step_events (execution_id, started_at);
+CREATE INDEX IF NOT EXISTS idx_routine_step_events_tenant_recipe
+  ON public.routine_step_events (tenant_id, recipe_type);
+CREATE INDEX IF NOT EXISTS idx_routine_step_events_python_dashboard
+  ON public.routine_step_events (tenant_id, recipe_type, created_at);
+
+-- ---------------------------------------------------------------------------
+-- routine_asl_versions
+-- ---------------------------------------------------------------------------
+
+CREATE TABLE IF NOT EXISTS public.routine_asl_versions (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  tenant_id uuid NOT NULL REFERENCES public.tenants(id),
+  routine_id uuid NOT NULL REFERENCES public.routines(id),
+  version_number integer NOT NULL,
+  state_machine_arn text NOT NULL,
+  version_arn text NOT NULL,
+  alias_was_pointing text,
+  asl_json jsonb NOT NULL,
+  markdown_summary text NOT NULL,
+  step_manifest_json jsonb NOT NULL,
+  validation_warnings_json jsonb,
+  published_by_actor_id uuid,
+  published_by_actor_type text,
+  created_at timestamp with time zone NOT NULL DEFAULT now()
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_routine_asl_versions_routine_version
+  ON public.routine_asl_versions (routine_id, version_number);
+CREATE INDEX IF NOT EXISTS idx_routine_asl_versions_tenant_routine
+  ON public.routine_asl_versions (tenant_id, routine_id);
+
+-- ---------------------------------------------------------------------------
+-- routine_approval_tokens
+-- ---------------------------------------------------------------------------
+
+CREATE TABLE IF NOT EXISTS public.routine_approval_tokens (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  tenant_id uuid NOT NULL REFERENCES public.tenants(id),
+  execution_id uuid NOT NULL REFERENCES public.routine_executions(id),
+  inbox_item_id uuid NOT NULL REFERENCES public.inbox_items(id),
+  node_id text NOT NULL,
+  task_token text NOT NULL,
+  heartbeat_seconds integer,
+  consumed boolean NOT NULL DEFAULT false,
+  decided_by_user_id uuid,
+  decision_value_json jsonb,
+  decided_at timestamp with time zone,
+  created_at timestamp with time zone NOT NULL DEFAULT now(),
+  expires_at timestamp with time zone
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_routine_approval_tokens_inbox
+  ON public.routine_approval_tokens (inbox_item_id);
+
+-- Partial unique index: at most one pending decision per (execution, node).
+-- Past decisions retain their rows for audit (consumed=true) without
+-- conflicting with new pending decisions on the same node.
+CREATE UNIQUE INDEX IF NOT EXISTS idx_routine_approval_tokens_pending
+  ON public.routine_approval_tokens (execution_id, node_id)
+  WHERE consumed = false;
+
+CREATE INDEX IF NOT EXISTS idx_routine_approval_tokens_tenant_consumed
+  ON public.routine_approval_tokens (tenant_id, consumed);
+
+COMMENT ON TABLE public.routine_executions IS 'routines-phase-a: docs/plans/2026-05-01-004-feat-routines-phase-a-substrate-plan.md';
+COMMENT ON TABLE public.routine_step_events IS 'routines-phase-a: docs/plans/2026-05-01-004-feat-routines-phase-a-substrate-plan.md';
+COMMENT ON TABLE public.routine_asl_versions IS 'routines-phase-a: docs/plans/2026-05-01-004-feat-routines-phase-a-substrate-plan.md';
+COMMENT ON TABLE public.routine_approval_tokens IS 'routines-phase-a: docs/plans/2026-05-01-004-feat-routines-phase-a-substrate-plan.md';
+
+COMMIT;

package/dist/drizzle/0056_routine_step_events_dedup_idx.sql

@@ -0,0 +1,25 @@
+-- Hand-rolled migration: routine_step_events dedup unique index
+-- Plan: docs/plans/2026-05-01-005-feat-routines-phase-b-runtime-plan.md §U9
+--
+-- The routine-step-callback handler ingests events fired from two paths
+-- that can both double-deliver:
+--   * Task-wrapper Lambdas (routine-task-python, routine-resume) on
+--     SFN Lambda-retry
+--   * EventBridge → routine-step-callback for SFN execution-state-change
+--     events on the agent_invoke recipe (no wrapper Lambda)
+--
+-- Idempotency relies on ON CONFLICT DO NOTHING against this unique index.
+-- The 4-tuple (execution_id, node_id, status, started_at) matches the
+-- schema's idempotency contract documented in
+-- packages/database-pg/src/schema/routine-step-events.ts.
+--
+-- Partial-index `WHERE started_at IS NOT NULL` because Postgres treats
+-- NULLs as distinct in unique indexes by default; events without a
+-- started_at fall back to non-deduped insert (rare and harmless — UI
+-- shows them as separate rows, not duplicates).
+--
+-- creates: public.idx_routine_step_events_dedup
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_routine_step_events_dedup
+  ON public.routine_step_events (execution_id, node_id, status, started_at)
+  WHERE started_at IS NOT NULL;

package/dist/drizzle/0057_archive_legacy_python_routines.sql

@@ -0,0 +1,36 @@
+-- Archive legacy Python routines (Plan 2026-05-01-008 §U15).
+--
+-- Phase A introduced an `engine` column on `routines` partitioning rows
+-- between `legacy_python` (pre-Phase-A code-backed routines) and
+-- `step_functions` (the new ASL substrate). Phase A through D shipped
+-- with both engines coexisting so the cutover wouldn't break in-flight
+-- legacy routines. Phase E archives the legacy partition.
+--
+-- Idempotent: re-running on a freshly migrated DB with zero
+-- `legacy_python` rows is a no-op. Reversible via the rollback file
+-- (status flips back to active for any rows that were active at the
+-- time of archival). Capture audit timestamps in routines.updated_at
+-- so the migration is observable downstream.
+--
+-- Pre-flight (dev): 0 routines exist. The migration is purely defensive
+-- for prod parity and any future tenant whose legacy_python rows didn't
+-- get migrated to ASL during the cutover.
+--
+-- creates-column: public.routines.archived_at_legacy_cutover
+
+-- Add a marker column so a later "drop the engine column" migration can
+-- distinguish "archived because legacy" from "archived for other
+-- reasons" (operator action, tenant offboarding). Nullable so existing
+-- rows aren't disrupted.
+ALTER TABLE public.routines
+  ADD COLUMN IF NOT EXISTS archived_at_legacy_cutover timestamptz;
+
+-- Archive every legacy_python routine that's not already archived.
+-- The status flip is the only behavior the v1 admin surface checks
+-- (Phase D filter); the marker column is for downstream observability.
+UPDATE public.routines
+   SET status = 'archived',
+       archived_at_legacy_cutover = now(),
+       updated_at = now()
+ WHERE engine = 'legacy_python'
+   AND status <> 'archived';