@opengeni/db 0.2.0

package/drizzle/0002_packs_and_social.sql

@@ -0,0 +1,99 @@
+CREATE TABLE IF NOT EXISTS "pack_installations" (
+  "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  "account_id" uuid NOT NULL REFERENCES "managed_accounts"("id") ON DELETE CASCADE,
+  "workspace_id" uuid NOT NULL REFERENCES "workspaces"("id") ON DELETE CASCADE,
+  "pack_id" text NOT NULL,
+  "status" text NOT NULL DEFAULT 'active',
+  "metadata" jsonb NOT NULL DEFAULT '{}'::jsonb,
+  "enabled_at" timestamptz NOT NULL DEFAULT now(),
+  "updated_at" timestamptz NOT NULL DEFAULT now()
+);
+CREATE UNIQUE INDEX IF NOT EXISTS "pack_installations_workspace_pack_idx" ON "pack_installations" ("workspace_id", "pack_id");
+CREATE INDEX IF NOT EXISTS "pack_installations_workspace_status_idx" ON "pack_installations" ("workspace_id", "status");
+ALTER TABLE "pack_installations" ENABLE ROW LEVEL SECURITY;
+ALTER TABLE "pack_installations" FORCE ROW LEVEL SECURITY;
+DO $$
+BEGIN
+  IF EXISTS (
+    SELECT 1 FROM pg_policies
+    WHERE schemaname = current_schema() AND tablename = 'pack_installations' AND policyname = 'workspace_isolation'
+  ) THEN
+    DROP POLICY workspace_isolation ON "pack_installations";
+  END IF;
+END $$;
+CREATE POLICY workspace_isolation ON "pack_installations"
+  USING (opengeni_private.workspace_rls_visible(account_id, workspace_id))
+  WITH CHECK (opengeni_private.workspace_rls_visible(account_id, workspace_id));
+
+CREATE TABLE IF NOT EXISTS "social_connections" (
+  "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  "account_id" uuid NOT NULL REFERENCES "managed_accounts"("id") ON DELETE CASCADE,
+  "workspace_id" uuid NOT NULL REFERENCES "workspaces"("id") ON DELETE CASCADE,
+  "provider" text NOT NULL,
+  "account_handle" text NOT NULL,
+  "account_name" text,
+  "external_account_id" text,
+  "status" text NOT NULL DEFAULT 'connected',
+  "scopes" jsonb NOT NULL DEFAULT '[]'::jsonb,
+  "credential_ref" text,
+  "token_metadata" jsonb NOT NULL DEFAULT '{}'::jsonb,
+  "metadata" jsonb NOT NULL DEFAULT '{}'::jsonb,
+  "created_at" timestamptz NOT NULL DEFAULT now(),
+  "updated_at" timestamptz NOT NULL DEFAULT now()
+);
+CREATE UNIQUE INDEX IF NOT EXISTS "social_connections_workspace_provider_handle_idx" ON "social_connections" ("workspace_id", "provider", "account_handle");
+CREATE INDEX IF NOT EXISTS "social_connections_workspace_provider_status_idx" ON "social_connections" ("workspace_id", "provider", "status");
+ALTER TABLE "social_connections" ENABLE ROW LEVEL SECURITY;
+ALTER TABLE "social_connections" FORCE ROW LEVEL SECURITY;
+DO $$
+BEGIN
+  IF EXISTS (
+    SELECT 1 FROM pg_policies
+    WHERE schemaname = current_schema() AND tablename = 'social_connections' AND policyname = 'workspace_isolation'
+  ) THEN
+    DROP POLICY workspace_isolation ON "social_connections";
+  END IF;
+END $$;
+CREATE POLICY workspace_isolation ON "social_connections"
+  USING (opengeni_private.workspace_rls_visible(account_id, workspace_id))
+  WITH CHECK (opengeni_private.workspace_rls_visible(account_id, workspace_id));
+
+CREATE TABLE IF NOT EXISTS "social_posts" (
+  "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  "account_id" uuid NOT NULL REFERENCES "managed_accounts"("id") ON DELETE CASCADE,
+  "workspace_id" uuid NOT NULL REFERENCES "workspaces"("id") ON DELETE CASCADE,
+  "connection_id" uuid NOT NULL REFERENCES "social_connections"("id") ON DELETE CASCADE,
+  "provider" text NOT NULL,
+  "external_post_id" text,
+  "url" text,
+  "author_handle" text,
+  "text" text NOT NULL,
+  "published_at" timestamptz NOT NULL,
+  "metrics" jsonb NOT NULL DEFAULT '{}'::jsonb,
+  "raw" jsonb NOT NULL DEFAULT '{}'::jsonb,
+  "created_at" timestamptz NOT NULL DEFAULT now()
+);
+CREATE UNIQUE INDEX IF NOT EXISTS "social_posts_workspace_connection_external_post_idx" ON "social_posts" ("workspace_id", "connection_id", "external_post_id");
+CREATE INDEX IF NOT EXISTS "social_posts_workspace_connection_published_idx" ON "social_posts" ("workspace_id", "connection_id", "published_at");
+CREATE INDEX IF NOT EXISTS "social_posts_workspace_provider_published_idx" ON "social_posts" ("workspace_id", "provider", "published_at");
+ALTER TABLE "social_posts" ENABLE ROW LEVEL SECURITY;
+ALTER TABLE "social_posts" FORCE ROW LEVEL SECURITY;
+DO $$
+BEGIN
+  IF EXISTS (
+    SELECT 1 FROM pg_policies
+    WHERE schemaname = current_schema() AND tablename = 'social_posts' AND policyname = 'workspace_isolation'
+  ) THEN
+    DROP POLICY workspace_isolation ON "social_posts";
+  END IF;
+END $$;
+CREATE POLICY workspace_isolation ON "social_posts"
+  USING (opengeni_private.workspace_rls_visible(account_id, workspace_id))
+  WITH CHECK (opengeni_private.workspace_rls_visible(account_id, workspace_id));
+
+DO $$
+BEGIN
+  IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'opengeni_app') THEN
+    GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO opengeni_app;
+  END IF;
+END $$;

package/drizzle/0003_capability_catalog.sql

@@ -0,0 +1,73 @@
+CREATE TABLE IF NOT EXISTS "capability_catalog_items" (
+  "id" text NOT NULL,
+  "account_id" uuid NOT NULL REFERENCES "managed_accounts"("id") ON DELETE CASCADE,
+  "workspace_id" uuid NOT NULL REFERENCES "workspaces"("id") ON DELETE CASCADE,
+  "kind" text NOT NULL,
+  "source" text NOT NULL DEFAULT 'manual',
+  "name" text NOT NULL,
+  "description" text,
+  "category" text NOT NULL DEFAULT 'custom',
+  "tags" jsonb NOT NULL DEFAULT '[]'::jsonb,
+  "homepage_url" text,
+  "endpoint_url" text,
+  "install_url" text,
+  "auth_model" text,
+  "metadata" jsonb NOT NULL DEFAULT '{}'::jsonb,
+  "created_at" timestamptz NOT NULL DEFAULT now(),
+  "updated_at" timestamptz NOT NULL DEFAULT now()
+);
+CREATE UNIQUE INDEX IF NOT EXISTS "capability_catalog_items_workspace_capability_idx" ON "capability_catalog_items" ("workspace_id", "id");
+CREATE INDEX IF NOT EXISTS "capability_catalog_items_workspace_kind_idx" ON "capability_catalog_items" ("workspace_id", "kind");
+CREATE INDEX IF NOT EXISTS "capability_catalog_items_workspace_category_idx" ON "capability_catalog_items" ("workspace_id", "category");
+CREATE INDEX IF NOT EXISTS "capability_catalog_items_workspace_source_idx" ON "capability_catalog_items" ("workspace_id", "source");
+ALTER TABLE "capability_catalog_items" ENABLE ROW LEVEL SECURITY;
+ALTER TABLE "capability_catalog_items" FORCE ROW LEVEL SECURITY;
+DO $$
+BEGIN
+  IF EXISTS (
+    SELECT 1 FROM pg_policies
+    WHERE schemaname = current_schema() AND tablename = 'capability_catalog_items' AND policyname = 'workspace_isolation'
+  ) THEN
+    DROP POLICY workspace_isolation ON "capability_catalog_items";
+  END IF;
+END $$;
+CREATE POLICY workspace_isolation ON "capability_catalog_items"
+  USING (opengeni_private.workspace_rls_visible(account_id, workspace_id))
+  WITH CHECK (opengeni_private.workspace_rls_visible(account_id, workspace_id));
+
+CREATE TABLE IF NOT EXISTS "capability_installations" (
+  "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  "account_id" uuid NOT NULL REFERENCES "managed_accounts"("id") ON DELETE CASCADE,
+  "workspace_id" uuid NOT NULL REFERENCES "workspaces"("id") ON DELETE CASCADE,
+  "capability_id" text NOT NULL,
+  "kind" text NOT NULL,
+  "status" text NOT NULL DEFAULT 'active',
+  "config" jsonb NOT NULL DEFAULT '{}'::jsonb,
+  "metadata" jsonb NOT NULL DEFAULT '{}'::jsonb,
+  "enabled_at" timestamptz NOT NULL DEFAULT now(),
+  "updated_at" timestamptz NOT NULL DEFAULT now()
+);
+CREATE UNIQUE INDEX IF NOT EXISTS "capability_installations_workspace_capability_idx" ON "capability_installations" ("workspace_id", "capability_id");
+CREATE INDEX IF NOT EXISTS "capability_installations_workspace_kind_idx" ON "capability_installations" ("workspace_id", "kind");
+CREATE INDEX IF NOT EXISTS "capability_installations_workspace_status_idx" ON "capability_installations" ("workspace_id", "status");
+ALTER TABLE "capability_installations" ENABLE ROW LEVEL SECURITY;
+ALTER TABLE "capability_installations" FORCE ROW LEVEL SECURITY;
+DO $$
+BEGIN
+  IF EXISTS (
+    SELECT 1 FROM pg_policies
+    WHERE schemaname = current_schema() AND tablename = 'capability_installations' AND policyname = 'workspace_isolation'
+  ) THEN
+    DROP POLICY workspace_isolation ON "capability_installations";
+  END IF;
+END $$;
+CREATE POLICY workspace_isolation ON "capability_installations"
+  USING (opengeni_private.workspace_rls_visible(account_id, workspace_id))
+  WITH CHECK (opengeni_private.workspace_rls_visible(account_id, workspace_id));
+
+DO $$
+BEGIN
+  IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'opengeni_app') THEN
+    GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO opengeni_app;
+  END IF;
+END $$;

package/drizzle/0004_workspace_environments.sql

@@ -0,0 +1,65 @@
+CREATE TABLE IF NOT EXISTS "workspace_environments" (
+  "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  "account_id" uuid NOT NULL REFERENCES "managed_accounts"("id") ON DELETE CASCADE,
+  "workspace_id" uuid NOT NULL REFERENCES "workspaces"("id") ON DELETE CASCADE,
+  "name" text NOT NULL,
+  "description" text,
+  "created_at" timestamptz NOT NULL DEFAULT now(),
+  "updated_at" timestamptz NOT NULL DEFAULT now()
+);
+CREATE UNIQUE INDEX IF NOT EXISTS "workspace_environments_workspace_name_idx" ON "workspace_environments" ("workspace_id", "name");
+CREATE INDEX IF NOT EXISTS "workspace_environments_workspace_created_idx" ON "workspace_environments" ("workspace_id", "created_at");
+ALTER TABLE "workspace_environments" ENABLE ROW LEVEL SECURITY;
+ALTER TABLE "workspace_environments" FORCE ROW LEVEL SECURITY;
+DO $$
+BEGIN
+  IF EXISTS (
+    SELECT 1 FROM pg_policies
+    WHERE schemaname = current_schema() AND tablename = 'workspace_environments' AND policyname = 'workspace_isolation'
+  ) THEN
+    DROP POLICY workspace_isolation ON "workspace_environments";
+  END IF;
+END $$;
+CREATE POLICY workspace_isolation ON "workspace_environments"
+  USING (opengeni_private.workspace_rls_visible(account_id, workspace_id))
+  WITH CHECK (opengeni_private.workspace_rls_visible(account_id, workspace_id));
+
+CREATE TABLE IF NOT EXISTS "workspace_environment_variables" (
+  "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  "account_id" uuid NOT NULL REFERENCES "managed_accounts"("id") ON DELETE CASCADE,
+  "workspace_id" uuid NOT NULL REFERENCES "workspaces"("id") ON DELETE CASCADE,
+  "environment_id" uuid NOT NULL REFERENCES "workspace_environments"("id") ON DELETE CASCADE,
+  "name" text NOT NULL,
+  "value_encrypted" text NOT NULL,
+  "version" integer NOT NULL DEFAULT 1,
+  "created_at" timestamptz NOT NULL DEFAULT now(),
+  "updated_at" timestamptz NOT NULL DEFAULT now()
+);
+CREATE UNIQUE INDEX IF NOT EXISTS "workspace_environment_variables_env_name_idx" ON "workspace_environment_variables" ("workspace_id", "environment_id", "name");
+CREATE INDEX IF NOT EXISTS "workspace_environment_variables_workspace_env_idx" ON "workspace_environment_variables" ("workspace_id", "environment_id");
+ALTER TABLE "workspace_environment_variables" ENABLE ROW LEVEL SECURITY;
+ALTER TABLE "workspace_environment_variables" FORCE ROW LEVEL SECURITY;
+DO $$
+BEGIN
+  IF EXISTS (
+    SELECT 1 FROM pg_policies
+    WHERE schemaname = current_schema() AND tablename = 'workspace_environment_variables' AND policyname = 'workspace_isolation'
+  ) THEN
+    DROP POLICY workspace_isolation ON "workspace_environment_variables";
+  END IF;
+END $$;
+CREATE POLICY workspace_isolation ON "workspace_environment_variables"
+  USING (opengeni_private.workspace_rls_visible(account_id, workspace_id))
+  WITH CHECK (opengeni_private.workspace_rls_visible(account_id, workspace_id));
+
+ALTER TABLE "sessions" ADD COLUMN IF NOT EXISTS "environment_id" uuid REFERENCES "workspace_environments"("id") ON DELETE SET NULL;
+ALTER TABLE "scheduled_tasks" ADD COLUMN IF NOT EXISTS "environment_id" uuid REFERENCES "workspace_environments"("id") ON DELETE RESTRICT;
+CREATE INDEX IF NOT EXISTS "sessions_environment_idx" ON "sessions" ("workspace_id", "environment_id");
+CREATE INDEX IF NOT EXISTS "scheduled_tasks_environment_idx" ON "scheduled_tasks" ("workspace_id", "environment_id");
+
+DO $$
+BEGIN
+  IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'opengeni_app') THEN
+    GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO opengeni_app;
+  END IF;
+END $$;

package/drizzle/0005_session_goals.sql

@@ -0,0 +1,45 @@
+CREATE TABLE IF NOT EXISTS "session_goals" (
+  "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  "account_id" uuid NOT NULL REFERENCES "managed_accounts"("id") ON DELETE CASCADE,
+  "workspace_id" uuid NOT NULL REFERENCES "workspaces"("id") ON DELETE CASCADE,
+  "session_id" uuid NOT NULL REFERENCES "sessions"("id") ON DELETE CASCADE,
+  "status" text NOT NULL DEFAULT 'active',
+  "text" text NOT NULL,
+  "success_criteria" text,
+  "evidence" text,
+  "rationale" text,
+  "paused_reason" text,
+  "created_by" text NOT NULL DEFAULT 'api',
+  "version" integer NOT NULL DEFAULT 1,
+  "auto_continuations" integer NOT NULL DEFAULT 0,
+  "no_progress_streak" integer NOT NULL DEFAULT 0,
+  "max_auto_continuations" integer,
+  "last_continuation_turn_id" uuid,
+  "version_at_last_continuation" integer,
+  "metadata" jsonb NOT NULL DEFAULT '{}'::jsonb,
+  "created_at" timestamptz NOT NULL DEFAULT now(),
+  "updated_at" timestamptz NOT NULL DEFAULT now()
+);
+CREATE UNIQUE INDEX IF NOT EXISTS "session_goals_workspace_session_idx" ON "session_goals" ("workspace_id", "session_id");
+CREATE INDEX IF NOT EXISTS "session_goals_workspace_status_idx" ON "session_goals" ("workspace_id", "status");
+ALTER TABLE "session_goals" ENABLE ROW LEVEL SECURITY;
+ALTER TABLE "session_goals" FORCE ROW LEVEL SECURITY;
+DO $$
+BEGIN
+  IF EXISTS (
+    SELECT 1 FROM pg_policies
+    WHERE schemaname = current_schema() AND tablename = 'session_goals' AND policyname = 'workspace_isolation'
+  ) THEN
+    DROP POLICY workspace_isolation ON "session_goals";
+  END IF;
+END $$;
+CREATE POLICY workspace_isolation ON "session_goals"
+  USING (opengeni_private.workspace_rls_visible(account_id, workspace_id))
+  WITH CHECK (opengeni_private.workspace_rls_visible(account_id, workspace_id));
+
+DO $$
+BEGIN
+  IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'opengeni_app') THEN
+    GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO opengeni_app;
+  END IF;
+END $$;

package/drizzle/0006_workspace_packs.sql

@@ -0,0 +1,31 @@
+CREATE TABLE IF NOT EXISTS "workspace_packs" (
+  "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  "account_id" uuid NOT NULL REFERENCES "managed_accounts"("id") ON DELETE CASCADE,
+  "workspace_id" uuid NOT NULL REFERENCES "workspaces"("id") ON DELETE CASCADE,
+  "pack_id" text NOT NULL,
+  "manifest" jsonb NOT NULL,
+  "created_at" timestamptz NOT NULL DEFAULT now(),
+  "updated_at" timestamptz NOT NULL DEFAULT now()
+);
+CREATE UNIQUE INDEX IF NOT EXISTS "workspace_packs_workspace_pack_idx" ON "workspace_packs" ("workspace_id", "pack_id");
+ALTER TABLE "workspace_packs" ENABLE ROW LEVEL SECURITY;
+ALTER TABLE "workspace_packs" FORCE ROW LEVEL SECURITY;
+DO $$
+BEGIN
+  IF EXISTS (
+    SELECT 1 FROM pg_policies
+    WHERE schemaname = current_schema() AND tablename = 'workspace_packs' AND policyname = 'workspace_isolation'
+  ) THEN
+    DROP POLICY workspace_isolation ON "workspace_packs";
+  END IF;
+END $$;
+CREATE POLICY workspace_isolation ON "workspace_packs"
+  USING (opengeni_private.workspace_rls_visible(account_id, workspace_id))
+  WITH CHECK (opengeni_private.workspace_rls_visible(account_id, workspace_id));
+
+DO $$
+BEGIN
+  IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'opengeni_app') THEN
+    GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO opengeni_app;
+  END IF;
+END $$;

package/drizzle/0007_session_history_items.sql

@@ -0,0 +1,66 @@
+-- Conversation truth as ordered, verbatim SDK input items (issue #35).
+-- The model-facing memory store: unredacted, replay-ready AgentInputItem JSON.
+-- session_events stays the redacted human/audit timeline; agent_run_states
+-- shrinks to mid-turn approval resume.
+CREATE TABLE IF NOT EXISTS "session_history_items" (
+  "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  "account_id" uuid NOT NULL REFERENCES "managed_accounts"("id") ON DELETE CASCADE,
+  "workspace_id" uuid NOT NULL REFERENCES "workspaces"("id") ON DELETE CASCADE,
+  "session_id" uuid NOT NULL REFERENCES "sessions"("id") ON DELETE CASCADE,
+  "turn_id" uuid REFERENCES "session_turns"("id") ON DELETE SET NULL,
+  "position" integer NOT NULL,
+  "item" jsonb NOT NULL,
+  "created_at" timestamptz NOT NULL DEFAULT now()
+);
+CREATE UNIQUE INDEX IF NOT EXISTS "session_history_items_position_idx"
+  ON "session_history_items" ("workspace_id", "session_id", "position");
+ALTER TABLE "session_history_items" ENABLE ROW LEVEL SECURITY;
+ALTER TABLE "session_history_items" FORCE ROW LEVEL SECURITY;
+DO $$
+BEGIN
+  IF EXISTS (
+    SELECT 1 FROM pg_policies
+    WHERE schemaname = current_schema() AND tablename = 'session_history_items' AND policyname = 'workspace_isolation'
+  ) THEN
+    DROP POLICY workspace_isolation ON "session_history_items";
+  END IF;
+END $$;
+CREATE POLICY workspace_isolation ON "session_history_items"
+  USING (opengeni_private.workspace_rls_visible(account_id, workspace_id))
+  WITH CHECK (opengeni_private.workspace_rls_visible(account_id, workspace_id));
+
+-- Sandbox recovery descriptor, decoupled from the RunState blob: the small
+-- versioned envelope (provider handle / snapshot ref / manifest) needed to
+-- reattach, restore, or rebuild the sandbox for a session's next turn.
+CREATE TABLE IF NOT EXISTS "sandbox_session_envelopes" (
+  "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  "account_id" uuid NOT NULL REFERENCES "managed_accounts"("id") ON DELETE CASCADE,
+  "workspace_id" uuid NOT NULL REFERENCES "workspaces"("id") ON DELETE CASCADE,
+  "session_id" uuid NOT NULL REFERENCES "sessions"("id") ON DELETE CASCADE,
+  "envelope" jsonb NOT NULL,
+  "created_at" timestamptz NOT NULL DEFAULT now(),
+  "updated_at" timestamptz NOT NULL DEFAULT now()
+);
+CREATE UNIQUE INDEX IF NOT EXISTS "sandbox_session_envelopes_session_idx"
+  ON "sandbox_session_envelopes" ("workspace_id", "session_id");
+ALTER TABLE "sandbox_session_envelopes" ENABLE ROW LEVEL SECURITY;
+ALTER TABLE "sandbox_session_envelopes" FORCE ROW LEVEL SECURITY;
+DO $$
+BEGIN
+  IF EXISTS (
+    SELECT 1 FROM pg_policies
+    WHERE schemaname = current_schema() AND tablename = 'sandbox_session_envelopes' AND policyname = 'workspace_isolation'
+  ) THEN
+    DROP POLICY workspace_isolation ON "sandbox_session_envelopes";
+  END IF;
+END $$;
+CREATE POLICY workspace_isolation ON "sandbox_session_envelopes"
+  USING (opengeni_private.workspace_rls_visible(account_id, workspace_id))
+  WITH CHECK (opengeni_private.workspace_rls_visible(account_id, workspace_id));
+
+DO $$
+BEGIN
+  IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'opengeni_app') THEN
+    GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO opengeni_app;
+  END IF;
+END $$;

package/drizzle/0008_session_first_party_mcp_permissions.sql

@@ -0,0 +1,5 @@
+-- Per-session first-party MCP token permissions (manager-style sessions).
+-- NULL means the fixed worker default permission set in @opengeni/runtime.
+-- Values are validated at session creation: every permission must be held by
+-- the creating grant, so a session can never out-rank its creator.
+ALTER TABLE "sessions" ADD COLUMN IF NOT EXISTS "first_party_mcp_permissions" jsonb;

package/drizzle/0009_goal_sessions_first_party_goals_manage.sql

@@ -0,0 +1,34 @@
+-- Goal-bearing sessions must always hold goals:manage in their first-party
+-- MCP permission set. A session created with a goal plus an explicit
+-- first_party_mcp_permissions list lacking goals:manage never sees the goal
+-- tools (goal_complete/goal_pause/goal_set/goal_update) on its delegated
+-- token, so the agent cannot stop its own goal and the continuation loop
+-- runs until an operator intervenes. Session creation now unions
+-- goals:manage into explicit lists for goal-bearing sessions; this backfills
+-- the rows created before that fix.
+--
+-- The backfill is scoped to sessions with a non-completed goal and an
+-- explicit permission list missing goals:manage, and is idempotent. NULL
+-- permission lists (the default worker set) already include goals:manage at
+-- token-signing time and are left untouched.
+--
+-- Migrations run as the table owner, which FORCE ROW LEVEL SECURITY would
+-- otherwise subject to the workspace-scoped policies (matching zero rows
+-- here, where no workspace GUCs are set). NO FORCE only affects the owner -
+-- the app role stays policy-bound throughout - and FORCE is restored within
+-- the same implicit transaction that runs this file.
+ALTER TABLE "sessions" NO FORCE ROW LEVEL SECURITY;
+ALTER TABLE "session_goals" NO FORCE ROW LEVEL SECURITY;
+UPDATE "sessions" s
+SET "first_party_mcp_permissions" = s."first_party_mcp_permissions" || '["goals:manage"]'::jsonb
+WHERE s."first_party_mcp_permissions" IS NOT NULL
+  AND jsonb_typeof(s."first_party_mcp_permissions") = 'array'
+  AND NOT s."first_party_mcp_permissions" @> '"goals:manage"'::jsonb
+  AND EXISTS (
+    SELECT 1 FROM "session_goals" g
+    WHERE g."workspace_id" = s."workspace_id"
+      AND g."session_id" = s."id"
+      AND g."status" <> 'completed'
+  );
+ALTER TABLE "sessions" FORCE ROW LEVEL SECURITY;
+ALTER TABLE "session_goals" FORCE ROW LEVEL SECURITY;

package/drizzle/0010_session_parent_linkage.sql

@@ -0,0 +1,30 @@
+-- Parent linkage for spawned worker sessions. When a session is created via
+-- the first-party MCP session_create tool and the caller's grant carries a
+-- worker-signed sessionId claim (i.e. a manager session spawning a worker),
+-- the new worker records that manager as its parent_session_id. Direct API
+-- creates and scheduled-task runs carry no such claim and leave this NULL.
+--
+-- The column powers event-driven completion wakeups: when a session that has
+-- a parent reaches a terminal-for-now state (goal completed, agent/system
+-- paused goal, idle with no active goal after doing work, or failed), the
+-- parent is woken with a system-authored message so the manager resumes and
+-- reads the worker's output instead of busy-polling or stalling.
+--
+-- Self-referencing FK with ON DELETE SET NULL: deleting a manager session must
+-- never cascade into its spawned workers; the link simply clears.
+ALTER TABLE "sessions" ADD COLUMN IF NOT EXISTS "parent_session_id" uuid;
+
+DO $$
+BEGIN
+  IF NOT EXISTS (
+    SELECT 1 FROM information_schema.table_constraints
+    WHERE constraint_name = 'sessions_parent_session_id_fkey'
+      AND table_name = 'sessions'
+  ) THEN
+    ALTER TABLE "sessions"
+      ADD CONSTRAINT "sessions_parent_session_id_fkey"
+      FOREIGN KEY ("parent_session_id") REFERENCES "sessions"("id") ON DELETE SET NULL;
+  END IF;
+END $$;
+
+CREATE INDEX IF NOT EXISTS "sessions_parent_idx" ON "sessions" ("workspace_id", "parent_session_id");

package/drizzle/0011_context_compaction.sql

@@ -0,0 +1,33 @@
+-- Provider-aware conversation context compaction (client-side path).
+--
+-- Long-lived sessions grow session_history_items unbounded until they overflow
+-- the model context window and 400 every turn. On Azure the server-side
+-- Responses-API compaction is unavailable, so OpenGeni runs its own
+-- client-side compaction: it summarizes an old turn-boundary-aligned prefix
+-- into one synthetic user message and supersedes (NOT deletes) the summarized
+-- rows so the full transcript survives as an audit trail.
+--
+-- "active": the live-row flag. The read path selects only active rows ordered
+-- by position => [active summary, ...active recent tail]. A compaction sets the
+-- summarized prefix rows inactive and inserts one active summary row at the
+-- boundary. Defaults true so all existing and normally-appended rows stay live.
+ALTER TABLE "session_history_items"
+  ADD COLUMN IF NOT EXISTS "active" boolean NOT NULL DEFAULT true;
+
+-- Fast active-row read per session (the live conversation-truth read path).
+CREATE INDEX IF NOT EXISTS "session_history_items_active_idx"
+  ON "session_history_items" ("workspace_id", "session_id", "position")
+  WHERE "active";
+
+-- Last model-call input tokens of the most recent turn: the pre-turn
+-- client-side compaction trigger reads it as its budget signal (char/4 over the
+-- active items is the same-turn fallback). Null until a turn with usage lands.
+ALTER TABLE "sessions"
+  ADD COLUMN IF NOT EXISTS "last_input_tokens" integer;
+
+DO $$
+BEGIN
+  IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'opengeni_app') THEN
+    GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO opengeni_app;
+  END IF;
+END $$;

package/drizzle/0012_compaction_summary_fractional_position.sql

@@ -0,0 +1,19 @@
+-- Audit-safe compaction summary placement.
+--
+-- The first cut of client-side compaction (0011) inserted the synthetic summary
+-- at integer position `boundaryPosition - 1`. Because history positions are
+-- always contiguous from 0, that position is ALWAYS occupied by a real prefix
+-- row, and the upsert overwrote that row's item JSON — destroying one real
+-- history row per compaction and violating the "supersede, never delete" audit
+-- guarantee (it also stranded the summary under the prefix row's old turn_id).
+--
+-- Fix: store the summary at a FRACTIONAL position (boundaryPosition - 0.5) that
+-- sorts immediately ahead of the kept tail and collides with nothing. That
+-- requires `position` to be numeric rather than integer. Normal appends keep
+-- whole-number positions; only the summary uses the half-step.
+--
+-- Safe in place: every existing position is a whole number, so the integer ->
+-- numeric widening is loss-free and the unique index is rebuilt automatically by
+-- the type change. No data is rewritten beyond the column representation.
+ALTER TABLE "session_history_items"
+  ALTER COLUMN "position" TYPE numeric USING "position"::numeric;

package/drizzle/0013_session_compact_requested.sql

@@ -0,0 +1,16 @@
+-- Operator /compact request flag (slash-command palette).
+--
+-- /compact is a manual trigger for the client-side (Azure) context compaction
+-- path. The API sets this flag true; the worker honors it BEFORE the next
+-- turn's model call by forcing a compaction (bypassing the token-budget
+-- trigger), then clears it. A durable column — not a transient signal — so the
+-- request survives a worker restart and converges before the next turn.
+ALTER TABLE "sessions"
+  ADD COLUMN IF NOT EXISTS "compact_requested" boolean NOT NULL DEFAULT false;
+
+DO $$
+BEGIN
+  IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'opengeni_app') THEN
+    GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO opengeni_app;
+  END IF;
+END $$;

package/drizzle/0014_repair_orphaned_function_call_results.sql

@@ -0,0 +1,125 @@
+-- One-time REPAIR of legacy orphaned tool-call RESULT rows (issue-61 self-heal).
+--
+-- Conversation truth is replayed verbatim into the model on every turn. The
+-- Responses API rejects the whole request (HTTP 400 "No tool call found for
+-- function call output with call_id <X>") when a tool-call RESULT row
+-- (function_call_result / computer_call_result / shell_call_output /
+-- apply_patch_call_output) has no matching CALL earlier in the active sequence.
+-- Because the corrupt row is replayed every turn, one such orphan permanently
+-- bricks the session across revival until the row is removed.
+--
+-- The read-path sanitizer (sanitizeHistoryItemsForModel) already filters these
+-- in-memory so new turns survive, and the write-path watermark fix (seed from
+-- the SANITIZED active length) stops new orphans from ever being persisted. But
+-- sessions corrupted BEFORE those fixes still carry the orphaned row on disk;
+-- the audit trail (session_get / session_events / exports) keeps surfacing a
+-- result with no call, and the row needlessly re-triggers the sanitizer every
+-- turn. This migration strips those already-persisted orphans once so corrupted
+-- sessions self-heal on disk, paired and audited.
+--
+-- DEFINITION OF AN ORPHAN (mirrors the sanitizer's rule 1 exactly):
+--   * The row is an ACTIVE result-type row (the live, model-facing sequence is
+--     the only thing the read path replays; superseded prefix rows are audit
+--     trail and never reach the model). active=false rows are left untouched.
+--   * No ACTIVE row of the matching CALL type, with the same correlation id,
+--     exists at a STRICTLY EARLIER position in the same (workspace, session).
+--   * Correlation id is read from BOTH the SDK camelCase `callId` and the wire
+--     snake_case `call_id`, matching the sanitizer's callIdOf().
+--
+-- We deliberately do NOT touch DANGLING CALLS (a call with no result yet): a
+-- call awaiting a not-yet-settled result is valid mid-turn, not corruption; the
+-- read-path sanitizer drops it transiently and it settles on the next pass.
+--
+-- Every deleted row is first copied verbatim into the permanent audit table
+-- session_history_items_repair_audit, so the repair is reversible and auditable.
+
+-- Permanent audit of every row this repair removed.
+CREATE TABLE IF NOT EXISTS "session_history_items_repair_audit" (
+  "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+  -- The original session_history_items row, captured verbatim. No FK back to the
+  -- source row: it is being deleted, and the audit must outlive it.
+  "source_id" uuid NOT NULL,
+  "account_id" uuid NOT NULL,
+  "workspace_id" uuid NOT NULL,
+  "session_id" uuid NOT NULL,
+  "turn_id" uuid,
+  "position" numeric NOT NULL,
+  "item" jsonb NOT NULL,
+  "source_created_at" timestamptz NOT NULL,
+  "repair_reason" text NOT NULL,
+  "repaired_at" timestamptz NOT NULL DEFAULT now()
+);
+
+-- Result-item types and the CALL type that settles each, kept in sync with the
+-- runtime sanitizer's RESULT_TYPE_BY_CALL_TYPE. Built once as a CTE so the
+-- DELETE and the audit INSERT share one definition of an orphan.
+WITH "result_call_pairs" ("result_type", "call_type") AS (
+  VALUES
+    ('function_call_result', 'function_call'),
+    ('computer_call_result', 'computer_call'),
+    ('shell_call_output', 'shell_call'),
+    ('apply_patch_call_output', 'apply_patch_call')
+),
+-- Every ACTIVE result-type row, with its correlation id and the call type that
+-- would settle it.
+"active_results" AS (
+  SELECT
+    h."id",
+    h."account_id",
+    h."workspace_id",
+    h."session_id",
+    h."turn_id",
+    h."position",
+    h."item",
+    h."created_at",
+    p."call_type",
+    COALESCE(h."item" ->> 'callId', h."item" ->> 'call_id') AS "call_id"
+  FROM "session_history_items" h
+  JOIN "result_call_pairs" p
+    ON p."result_type" = (h."item" ->> 'type')
+  WHERE h."active" = true
+    AND COALESCE(h."item" ->> 'callId', h."item" ->> 'call_id') IS NOT NULL
+),
+-- The orphans: an active result row with NO active matching call at a strictly
+-- earlier position in the same session.
+"orphans" AS (
+  SELECT r.*
+  FROM "active_results" r
+  WHERE NOT EXISTS (
+    SELECT 1
+    FROM "session_history_items" c
+    WHERE c."workspace_id" = r."workspace_id"
+      AND c."session_id" = r."session_id"
+      AND c."active" = true
+      AND (c."item" ->> 'type') = r."call_type"
+      AND COALESCE(c."item" ->> 'callId', c."item" ->> 'call_id') = r."call_id"
+      AND c."position" < r."position"
+  )
+),
+-- Audit every orphan before deleting it.
+"audited" AS (
+  INSERT INTO "session_history_items_repair_audit" (
+    "source_id", "account_id", "workspace_id", "session_id", "turn_id",
+    "position", "item", "source_created_at", "repair_reason"
+  )
+  SELECT
+    o."id", o."account_id", o."workspace_id", o."session_id", o."turn_id",
+    o."position", o."item", o."created_at",
+    'orphaned_tool_call_result_no_matching_call'
+  FROM "orphans" o
+  RETURNING "source_id"
+)
+DELETE FROM "session_history_items" h
+USING "audited" a
+WHERE h."id" = a."source_id";
+
+-- The audit table holds no workspace-scoped RLS (it is an operator/audit
+-- artifact written only by this migration), but grant the app role the same
+-- table access the rest of the schema gets so a later GRANT-ALL sweep is
+-- idempotent and the role inventory stays uniform.
+DO $$
+BEGIN
+  IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'opengeni_app') THEN
+    GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO opengeni_app;
+  END IF;
+END $$;