@flowdular/sdk 0.1.0

package/modules/agents/migrations/0006_agent_skills.up.sql

@@ -0,0 +1,44 @@
+CREATE TABLE IF NOT EXISTS agent_skills (
+  id TEXT PRIMARY KEY,
+  tenant_id TEXT NOT NULL,
+  skill_key TEXT NOT NULL,
+  name TEXT NOT NULL,
+  description TEXT NOT NULL,
+  instructions TEXT NOT NULL,
+  required_tools_json TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('draft', 'active', 'archived')),
+  revision INTEGER NOT NULL CHECK (revision >= 1),
+  created_by TEXT NOT NULL,
+  created_at BIGINT NOT NULL,
+  updated_by TEXT NOT NULL,
+  updated_at BIGINT NOT NULL,
+  UNIQUE (tenant_id, skill_key),
+  UNIQUE (id, tenant_id)
+);
+CREATE INDEX IF NOT EXISTS agent_skills_tenant_name_idx ON agent_skills (tenant_id, name, id);
+CREATE TABLE IF NOT EXISTS agent_skill_assignments (
+  agent_id TEXT NOT NULL REFERENCES agent_definitions(id) ON DELETE CASCADE,
+  skill_id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  PRIMARY KEY (agent_id, skill_id),
+  FOREIGN KEY (skill_id, tenant_id) REFERENCES agent_skills(id, tenant_id) ON DELETE CASCADE
+);
+CREATE TABLE IF NOT EXISTS agent_run_skill_snapshots (
+  run_id TEXT NOT NULL REFERENCES agent_runs(id) ON DELETE CASCADE,
+  skill_id TEXT NOT NULL,
+  skill_key TEXT NOT NULL,
+  skill_name TEXT NOT NULL,
+  skill_revision INTEGER NOT NULL,
+  required_tools_json TEXT NOT NULL,
+  PRIMARY KEY (run_id, skill_id)
+);
+ALTER TABLE agent_skills ENABLE ROW LEVEL SECURITY;
+ALTER TABLE agent_skills FORCE ROW LEVEL SECURITY;
+CREATE POLICY agent_skills_tenant_policy ON agent_skills
+  USING (tenant_id = current_setting('coreloom.tenant_id', true))
+  WITH CHECK (tenant_id = current_setting('coreloom.tenant_id', true));
+ALTER TABLE agent_skill_assignments ENABLE ROW LEVEL SECURITY;
+ALTER TABLE agent_skill_assignments FORCE ROW LEVEL SECURITY;
+CREATE POLICY agent_skill_assignments_tenant_policy ON agent_skill_assignments
+  USING (tenant_id = current_setting('coreloom.tenant_id', true))
+  WITH CHECK (tenant_id = current_setting('coreloom.tenant_id', true));

package/modules/agents/migrations/0007_model_readiness.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS agent_provider_model_readiness;

package/modules/agents/migrations/0007_model_readiness.up.sql

@@ -0,0 +1,18 @@
+CREATE TABLE IF NOT EXISTS agent_provider_model_readiness (
+  provider_id TEXT NOT NULL REFERENCES agent_provider_connections(id) ON DELETE CASCADE,
+  model_id TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('healthy', 'unhealthy')),
+  latency_ms BIGINT,
+  error_code TEXT,
+  checked_at BIGINT NOT NULL,
+  PRIMARY KEY (provider_id, model_id)
+);
+INSERT INTO agent_provider_model_readiness
+  (provider_id, model_id, status, latency_ms, error_code, checked_at)
+  SELECT id, readiness_model, readiness_status, readiness_latency_ms,
+         readiness_error_code, readiness_checked_at
+  FROM agent_provider_connections
+  WHERE readiness_model IS NOT NULL
+    AND readiness_checked_at IS NOT NULL
+    AND readiness_status IN ('healthy', 'unhealthy')
+ON CONFLICT DO NOTHING;

package/modules/agents/migrations/0008_output_limits.down.sql

@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS agent_run_output_limits;
+DROP TABLE IF EXISTS agent_definition_output_limits;

package/modules/agents/migrations/0008_output_limits.up.sql

@@ -0,0 +1,8 @@
+CREATE TABLE IF NOT EXISTS agent_definition_output_limits (
+  agent_id TEXT PRIMARY KEY REFERENCES agent_definitions(id) ON DELETE CASCADE,
+  max_output_tokens BIGINT NOT NULL CHECK (max_output_tokens BETWEEN 256 AND 65536)
+);
+CREATE TABLE IF NOT EXISTS agent_run_output_limits (
+  run_id TEXT PRIMARY KEY REFERENCES agent_runs(id) ON DELETE CASCADE,
+  max_output_tokens BIGINT NOT NULL CHECK (max_output_tokens BETWEEN 256 AND 65536)
+);

package/modules/agents/migrations/0009_agent_audit_v3.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS agent_audit_events_v3;

package/modules/agents/migrations/0009_agent_audit_v3.up.sql

@@ -0,0 +1,25 @@
+CREATE TABLE IF NOT EXISTS agent_audit_events_v3 (
+  id TEXT PRIMARY KEY,
+  tenant_id TEXT NOT NULL,
+  sequence BIGINT NOT NULL,
+  actor_id TEXT NOT NULL,
+  action TEXT NOT NULL,
+  subject_type TEXT NOT NULL CHECK (subject_type IN ('agent', 'agent-run', 'agent-provider', 'agent-skill', 'agent-schedule', 'agent-trigger')),
+  subject_id TEXT NOT NULL,
+  metadata_json TEXT NOT NULL,
+  occurred_at BIGINT NOT NULL,
+  previous_hash TEXT,
+  event_hash TEXT NOT NULL,
+  UNIQUE (tenant_id, sequence),
+  UNIQUE (tenant_id, event_hash)
+);
+INSERT INTO agent_audit_events_v3
+  SELECT * FROM agent_audit_events_v2 ORDER BY tenant_id, sequence
+ON CONFLICT DO NOTHING;
+CREATE INDEX IF NOT EXISTS agent_audit_v3_tenant_time_idx
+  ON agent_audit_events_v3 (tenant_id, occurred_at DESC, sequence DESC);
+ALTER TABLE agent_audit_events_v3 ENABLE ROW LEVEL SECURITY;
+ALTER TABLE agent_audit_events_v3 FORCE ROW LEVEL SECURITY;
+CREATE POLICY agent_audit_events_v3_tenant_policy ON agent_audit_events_v3
+  USING (tenant_id = current_setting('coreloom.tenant_id', true))
+  WITH CHECK (tenant_id = current_setting('coreloom.tenant_id', true));

package/modules/agents/migrations/0012_agent_run_costs.down.sql

@@ -0,0 +1,3 @@
+DROP INDEX IF EXISTS agent_run_costs_tenant_agent_idx;
+DROP INDEX IF EXISTS agent_run_costs_tenant_day_idx;
+DROP TABLE IF EXISTS agent_run_costs;

package/modules/agents/migrations/0012_agent_run_costs.up.sql

@@ -0,0 +1,32 @@
+CREATE TABLE IF NOT EXISTS agent_run_costs (
+  run_id TEXT PRIMARY KEY REFERENCES agent_runs(id) ON DELETE CASCADE,
+  tenant_id TEXT NOT NULL,
+  agent_id TEXT NOT NULL,
+  agent_name TEXT NOT NULL,
+  model TEXT NOT NULL,
+  day TEXT NOT NULL,
+  input_tokens BIGINT NOT NULL,
+  output_tokens BIGINT NOT NULL,
+  cost_micro_usd BIGINT,
+  completed_at BIGINT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS agent_run_costs_tenant_day_idx
+  ON agent_run_costs (tenant_id, day);
+CREATE INDEX IF NOT EXISTS agent_run_costs_tenant_agent_idx
+  ON agent_run_costs (tenant_id, agent_id, day);
+INSERT INTO agent_run_costs
+  (run_id, tenant_id, agent_id, agent_name, model, day, input_tokens,
+   output_tokens, cost_micro_usd, completed_at)
+  SELECT id, tenant_id, agent_id, agent_name, model,
+         to_char(to_timestamp(completed_at / 1000), 'YYYY-MM-DD'),
+         COALESCE((usage_json::jsonb ->> 'inputTokens')::bigint, 0),
+         COALESCE((usage_json::jsonb ->> 'outputTokens')::bigint, 0),
+         NULL, completed_at
+  FROM agent_runs
+  WHERE status = 'succeeded' AND usage_json IS NOT NULL AND completed_at IS NOT NULL
+ON CONFLICT DO NOTHING;
+ALTER TABLE agent_run_costs ENABLE ROW LEVEL SECURITY;
+ALTER TABLE agent_run_costs FORCE ROW LEVEL SECURITY;
+CREATE POLICY agent_run_costs_tenant_policy ON agent_run_costs
+  USING (tenant_id = current_setting('coreloom.tenant_id', true))
+  WITH CHECK (tenant_id = current_setting('coreloom.tenant_id', true));

package/modules/agents/migrations/0013_workflow_prerequisites.down.sql

@@ -0,0 +1,3 @@
+DROP TABLE IF EXISTS agent_action_invocations;
+DROP TABLE IF EXISTS agent_run_contracts;
+DROP TABLE IF EXISTS agent_definition_revisions;

package/modules/agents/migrations/0013_workflow_prerequisites.up.sql

@@ -0,0 +1,97 @@
+-- SQLite expresses immutability with a BEFORE trigger that aborts. PostgreSQL
+-- needs a function to raise from, shared by every immutable table here.
+CREATE OR REPLACE FUNCTION coreloom_reject_change() RETURNS trigger AS $$
+BEGIN
+  RAISE EXCEPTION '%', TG_ARGV[0];
+END;
+$$ LANGUAGE plpgsql;
+CREATE TABLE IF NOT EXISTS agent_definition_revisions (
+  tenant_id TEXT NOT NULL,
+  agent_id TEXT NOT NULL,
+  revision INTEGER NOT NULL CHECK (revision >= 1),
+  agent_key TEXT NOT NULL,
+  name TEXT NOT NULL,
+  description TEXT NOT NULL,
+  instructions TEXT NOT NULL,
+  provider TEXT NOT NULL,
+  model TEXT NOT NULL,
+  allowed_tools_json TEXT NOT NULL,
+  skills_json TEXT NOT NULL,
+  max_steps INTEGER NOT NULL CHECK (max_steps BETWEEN 1 AND 32),
+  timeout_ms BIGINT NOT NULL CHECK (timeout_ms BETWEEN 250 AND 86400000),
+  temperature_milli INTEGER NOT NULL CHECK (temperature_milli BETWEEN 0 AND 2000),
+  max_output_tokens BIGINT NOT NULL CHECK (max_output_tokens BETWEEN 256 AND 65536),
+  status TEXT NOT NULL CHECK (status IN ('draft', 'active', 'paused', 'archived')),
+  retained_by TEXT NOT NULL,
+  retained_at BIGINT NOT NULL,
+  PRIMARY KEY (tenant_id, agent_id, revision)
+);
+CREATE INDEX IF NOT EXISTS agent_definition_revisions_tenant_agent_idx
+  ON agent_definition_revisions (tenant_id, agent_id, revision DESC);
+CREATE TRIGGER agent_definition_revisions_no_update
+  BEFORE UPDATE ON agent_definition_revisions
+  FOR EACH ROW EXECUTE FUNCTION coreloom_reject_change('agent definition revisions are immutable');
+CREATE TRIGGER agent_definition_revisions_no_delete
+  BEFORE DELETE ON agent_definition_revisions
+  FOR EACH ROW EXECUTE FUNCTION coreloom_reject_change('agent definition revisions are immutable');
+
+CREATE TABLE IF NOT EXISTS agent_run_contracts (
+  run_id TEXT PRIMARY KEY REFERENCES agent_runs(id) ON DELETE CASCADE,
+  tenant_id TEXT NOT NULL,
+  workflow_run_id TEXT,
+  output_contract_json TEXT NOT NULL,
+  structured_output_json TEXT,
+  request_hash TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS agent_run_contracts_tenant_workflow_idx
+  ON agent_run_contracts (tenant_id, workflow_run_id, run_id);
+INSERT INTO agent_run_contracts
+  (run_id, tenant_id, workflow_run_id, output_contract_json,
+   structured_output_json, request_hash)
+  SELECT id, tenant_id, NULL, '{"kind":"text"}', NULL,
+         encode(sha256(gen_random_uuid()::text::bytea), 'hex')
+  FROM agent_runs
+ON CONFLICT DO NOTHING;
+
+CREATE TABLE IF NOT EXISTS agent_action_invocations (
+  id TEXT PRIMARY KEY,
+  tenant_id TEXT NOT NULL,
+  workflow_run_id TEXT NOT NULL,
+  node_run_id TEXT NOT NULL,
+  action_id TEXT NOT NULL,
+  contract_version INTEGER NOT NULL CHECK (contract_version >= 1),
+  actor_json TEXT NOT NULL,
+  permission_snapshot_json TEXT NOT NULL,
+  input_json TEXT NOT NULL,
+  idempotency_key TEXT NOT NULL,
+  request_hash TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('queued', 'running', 'succeeded', 'failed', 'cancelled')),
+  output_json TEXT,
+  failure_code TEXT,
+  attempt INTEGER NOT NULL DEFAULT 0,
+  queued_at BIGINT NOT NULL,
+  started_at BIGINT,
+  completed_at BIGINT,
+  lease_owner TEXT,
+  lease_expires_at BIGINT,
+  UNIQUE (tenant_id, idempotency_key)
+);
+CREATE INDEX IF NOT EXISTS agent_actions_tenant_workflow_idx
+  ON agent_action_invocations (tenant_id, workflow_run_id, queued_at DESC, id);
+CREATE INDEX IF NOT EXISTS agent_actions_recovery_idx
+  ON agent_action_invocations (status, lease_expires_at, queued_at);
+ALTER TABLE agent_definition_revisions ENABLE ROW LEVEL SECURITY;
+ALTER TABLE agent_definition_revisions FORCE ROW LEVEL SECURITY;
+CREATE POLICY agent_definition_revisions_tenant_policy ON agent_definition_revisions
+  USING (tenant_id = current_setting('coreloom.tenant_id', true))
+  WITH CHECK (tenant_id = current_setting('coreloom.tenant_id', true));
+ALTER TABLE agent_run_contracts ENABLE ROW LEVEL SECURITY;
+ALTER TABLE agent_run_contracts FORCE ROW LEVEL SECURITY;
+CREATE POLICY agent_run_contracts_tenant_policy ON agent_run_contracts
+  USING (tenant_id = current_setting('coreloom.tenant_id', true))
+  WITH CHECK (tenant_id = current_setting('coreloom.tenant_id', true));
+ALTER TABLE agent_action_invocations ENABLE ROW LEVEL SECURITY;
+ALTER TABLE agent_action_invocations FORCE ROW LEVEL SECURITY;
+CREATE POLICY agent_action_invocations_tenant_policy ON agent_action_invocations
+  USING (tenant_id = current_setting('coreloom.tenant_id', true))
+  WITH CHECK (tenant_id = current_setting('coreloom.tenant_id', true));

package/modules/agents/migrations/0014_agent_action_audit.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS agent_audit_events_v4;

package/modules/agents/migrations/0014_agent_action_audit.up.sql

@@ -0,0 +1,25 @@
+CREATE TABLE IF NOT EXISTS agent_audit_events_v4 (
+  id TEXT PRIMARY KEY,
+  tenant_id TEXT NOT NULL,
+  sequence BIGINT NOT NULL,
+  actor_id TEXT NOT NULL,
+  action TEXT NOT NULL,
+  subject_type TEXT NOT NULL CHECK (subject_type IN ('agent', 'agent-run', 'agent-provider', 'agent-skill', 'agent-schedule', 'agent-trigger', 'agent-action')),
+  subject_id TEXT NOT NULL,
+  metadata_json TEXT NOT NULL,
+  occurred_at BIGINT NOT NULL,
+  previous_hash TEXT,
+  event_hash TEXT NOT NULL,
+  UNIQUE (tenant_id, sequence),
+  UNIQUE (tenant_id, event_hash)
+);
+INSERT INTO agent_audit_events_v4
+  SELECT * FROM agent_audit_events_v3 ORDER BY tenant_id, sequence
+ON CONFLICT DO NOTHING;
+CREATE INDEX IF NOT EXISTS agent_audit_v4_tenant_time_idx
+  ON agent_audit_events_v4 (tenant_id, occurred_at DESC, sequence DESC);
+ALTER TABLE agent_audit_events_v4 ENABLE ROW LEVEL SECURITY;
+ALTER TABLE agent_audit_events_v4 FORCE ROW LEVEL SECURITY;
+CREATE POLICY agent_audit_events_v4_tenant_policy ON agent_audit_events_v4
+  USING (tenant_id = current_setting('coreloom.tenant_id', true))
+  WITH CHECK (tenant_id = current_setting('coreloom.tenant_id', true));

package/modules/agents/migrations/0015_agent_run_actors.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS agent_run_actors;

package/modules/agents/migrations/0015_agent_run_actors.up.sql

@@ -0,0 +1,17 @@
+CREATE TABLE IF NOT EXISTS agent_run_actors (
+  run_id TEXT PRIMARY KEY REFERENCES agent_runs(id) ON DELETE CASCADE,
+  tenant_id TEXT NOT NULL,
+  actor_json TEXT NOT NULL CHECK (actor_json IS JSON OBJECT)
+);
+CREATE INDEX IF NOT EXISTS agent_run_actors_tenant_idx
+  ON agent_run_actors (tenant_id, run_id);
+INSERT INTO agent_run_actors (run_id, tenant_id, actor_json)
+  SELECT id, tenant_id,
+         jsonb_build_object('kind', 'user', 'id', requested_by, 'label', requested_by)::text
+  FROM agent_runs
+ON CONFLICT DO NOTHING;
+ALTER TABLE agent_run_actors ENABLE ROW LEVEL SECURITY;
+ALTER TABLE agent_run_actors FORCE ROW LEVEL SECURITY;
+CREATE POLICY agent_run_actors_tenant_policy ON agent_run_actors
+  USING (tenant_id = current_setting('coreloom.tenant_id', true))
+  WITH CHECK (tenant_id = current_setting('coreloom.tenant_id', true));

package/modules/agents/migrations/0016_module_owned_agents.down.sql

@@ -0,0 +1,6 @@
+DROP TRIGGER IF EXISTS agent_revision_ownership_no_delete;
+DROP TRIGGER IF EXISTS agent_revision_ownership_no_update;
+DROP TABLE IF EXISTS agent_revision_ownership;
+DROP INDEX IF EXISTS module_agent_bindings_tenant_status_idx;
+DROP TABLE IF EXISTS module_agent_bindings;
+DROP TABLE IF EXISTS module_agent_definitions;

package/modules/agents/migrations/0016_module_owned_agents.up.sql

@@ -0,0 +1,68 @@
+-- SQLite expresses immutability with a BEFORE trigger that aborts. PostgreSQL
+-- needs a function to raise from, shared by every immutable table here.
+CREATE OR REPLACE FUNCTION coreloom_reject_change() RETURNS trigger AS $$
+BEGIN
+  RAISE EXCEPTION '%', TG_ARGV[0];
+END;
+$$ LANGUAGE plpgsql;
+CREATE TABLE IF NOT EXISTS module_agent_definitions (
+  agent_id TEXT PRIMARY KEY REFERENCES agent_definitions(id),
+  module_id TEXT NOT NULL,
+  agent_key TEXT NOT NULL,
+  definition_revision INTEGER NOT NULL CHECK (definition_revision >= 1),
+  content_hash TEXT NOT NULL,
+  name TEXT NOT NULL,
+  description TEXT NOT NULL,
+  instructions TEXT NOT NULL,
+  allowed_tools_json TEXT NOT NULL,
+  max_steps INTEGER NOT NULL CHECK (max_steps BETWEEN 1 AND 32),
+  timeout_ms BIGINT NOT NULL CHECK (timeout_ms BETWEEN 250 AND 86400000),
+  temperature_milli INTEGER NOT NULL CHECK (temperature_milli BETWEEN 0 AND 2000),
+  max_output_tokens BIGINT NOT NULL CHECK (max_output_tokens BETWEEN 256 AND 65536),
+  registered_at BIGINT NOT NULL,
+  UNIQUE (module_id, agent_key)
+);
+
+CREATE TABLE IF NOT EXISTS module_agent_bindings (
+  tenant_id TEXT NOT NULL,
+  agent_id TEXT NOT NULL REFERENCES module_agent_definitions(agent_id),
+  provider TEXT NOT NULL,
+  model TEXT NOT NULL,
+  enabled_tools_json TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('active', 'paused')),
+  module_definition_revision INTEGER NOT NULL CHECK (module_definition_revision >= 1),
+  executable_revision INTEGER NOT NULL CHECK (executable_revision >= 1),
+  revision INTEGER NOT NULL CHECK (revision >= 1),
+  updated_by TEXT NOT NULL,
+  updated_at BIGINT NOT NULL,
+  PRIMARY KEY (tenant_id, agent_id)
+);
+CREATE INDEX IF NOT EXISTS module_agent_bindings_tenant_status_idx
+  ON module_agent_bindings (tenant_id, status, agent_id);
+
+CREATE TABLE IF NOT EXISTS agent_revision_ownership (
+  tenant_id TEXT NOT NULL,
+  agent_id TEXT NOT NULL,
+  revision INTEGER NOT NULL,
+  module_id TEXT NOT NULL,
+  module_definition_revision INTEGER NOT NULL CHECK (module_definition_revision >= 1),
+  PRIMARY KEY (tenant_id, agent_id, revision),
+  FOREIGN KEY (tenant_id, agent_id, revision)
+    REFERENCES agent_definition_revisions (tenant_id, agent_id, revision)
+);
+CREATE TRIGGER agent_revision_ownership_no_update
+  BEFORE UPDATE ON agent_revision_ownership
+  FOR EACH ROW EXECUTE FUNCTION coreloom_reject_change('agent revision ownership is immutable');
+CREATE TRIGGER agent_revision_ownership_no_delete
+  BEFORE DELETE ON agent_revision_ownership
+  FOR EACH ROW EXECUTE FUNCTION coreloom_reject_change('agent revision ownership is immutable');
+ALTER TABLE module_agent_bindings ENABLE ROW LEVEL SECURITY;
+ALTER TABLE module_agent_bindings FORCE ROW LEVEL SECURITY;
+CREATE POLICY module_agent_bindings_tenant_policy ON module_agent_bindings
+  USING (tenant_id = current_setting('coreloom.tenant_id', true))
+  WITH CHECK (tenant_id = current_setting('coreloom.tenant_id', true));
+ALTER TABLE agent_revision_ownership ENABLE ROW LEVEL SECURITY;
+ALTER TABLE agent_revision_ownership FORCE ROW LEVEL SECURITY;
+CREATE POLICY agent_revision_ownership_tenant_policy ON agent_revision_ownership
+  USING (tenant_id = current_setting('coreloom.tenant_id', true))
+  WITH CHECK (tenant_id = current_setting('coreloom.tenant_id', true));

package/modules/agents/migrations/0017_agent_authorization_subjects.down.sql

@@ -0,0 +1,2 @@
+ALTER TABLE agent_action_invocations DROP COLUMN authorization_subject_json;
+ALTER TABLE agent_run_actors DROP COLUMN authorization_subject_json;

package/modules/agents/migrations/0017_agent_authorization_subjects.up.sql

@@ -0,0 +1,18 @@
+ALTER TABLE agent_run_actors
+  ADD COLUMN authorization_subject_json TEXT CHECK (authorization_subject_json IS NULL OR (authorization_subject_json IS JSON AND authorization_subject_json::jsonb ->> 'kind' = 'user'));
+UPDATE agent_run_actors
+SET authorization_subject_json = CASE actor_json::jsonb ->> 'kind'
+  WHEN 'user' THEN actor_json
+  WHEN 'service' THEN actor_json::jsonb ->> 'configuredBy'
+  ELSE NULL
+END
+WHERE authorization_subject_json IS NULL;
+ALTER TABLE agent_action_invocations
+  ADD COLUMN authorization_subject_json TEXT CHECK (authorization_subject_json IS NULL OR (authorization_subject_json IS JSON AND authorization_subject_json::jsonb ->> 'kind' = 'user'));
+UPDATE agent_action_invocations
+SET authorization_subject_json = CASE actor_json::jsonb ->> 'kind'
+  WHEN 'user' THEN actor_json
+  WHEN 'service' THEN actor_json::jsonb ->> 'configuredBy'
+  ELSE NULL
+END
+WHERE authorization_subject_json IS NULL;

package/modules/agents/migrations/0018_agent_child_tenant_isolation.down.sql

@@ -0,0 +1,12 @@
+DROP POLICY IF EXISTS agent_provider_model_readiness_tenant_policy ON agent_provider_model_readiness;
+DROP POLICY IF EXISTS agent_run_skill_snapshots_tenant_policy ON agent_run_skill_snapshots;
+DROP POLICY IF EXISTS agent_run_output_limits_tenant_policy ON agent_run_output_limits;
+DROP POLICY IF EXISTS agent_run_execution_limits_tenant_policy ON agent_run_execution_limits;
+DROP POLICY IF EXISTS agent_definition_output_limits_tenant_policy ON agent_definition_output_limits;
+DROP POLICY IF EXISTS agent_definition_execution_limits_tenant_policy ON agent_definition_execution_limits;
+ALTER TABLE agent_provider_model_readiness DROP COLUMN IF EXISTS tenant_id;
+ALTER TABLE agent_run_skill_snapshots DROP COLUMN IF EXISTS tenant_id;
+ALTER TABLE agent_run_output_limits DROP COLUMN IF EXISTS tenant_id;
+ALTER TABLE agent_run_execution_limits DROP COLUMN IF EXISTS tenant_id;
+ALTER TABLE agent_definition_output_limits DROP COLUMN IF EXISTS tenant_id;
+ALTER TABLE agent_definition_execution_limits DROP COLUMN IF EXISTS tenant_id;

package/modules/agents/migrations/0018_agent_child_tenant_isolation.up.sql

@@ -0,0 +1,88 @@
+-- These tables hang off a tenant-owned parent and were protected only by it.
+-- A read by a caller-supplied parent id therefore crossed tenants with nothing
+-- but application code in the way. Each one now carries its own tenant and the
+-- same forced row security every other tenant table has, so a mistake in a
+-- query cannot reach another workspace.
+ALTER TABLE agent_definition_execution_limits ADD COLUMN tenant_id TEXT;
+UPDATE agent_definition_execution_limits AS child
+SET tenant_id = parent.tenant_id
+FROM agent_definitions AS parent
+WHERE parent.id = child.agent_id AND child.tenant_id IS NULL;
+DELETE FROM agent_definition_execution_limits WHERE tenant_id IS NULL;
+ALTER TABLE agent_definition_execution_limits ALTER COLUMN tenant_id SET NOT NULL;
+ALTER TABLE agent_definition_execution_limits ENABLE ROW LEVEL SECURITY;
+ALTER TABLE agent_definition_execution_limits FORCE ROW LEVEL SECURITY;
+CREATE POLICY agent_definition_execution_limits_tenant_policy
+  ON agent_definition_execution_limits
+  USING (tenant_id = current_setting('coreloom.tenant_id', true))
+  WITH CHECK (tenant_id = current_setting('coreloom.tenant_id', true));
+
+ALTER TABLE agent_definition_output_limits ADD COLUMN tenant_id TEXT;
+UPDATE agent_definition_output_limits AS child
+SET tenant_id = parent.tenant_id
+FROM agent_definitions AS parent
+WHERE parent.id = child.agent_id AND child.tenant_id IS NULL;
+DELETE FROM agent_definition_output_limits WHERE tenant_id IS NULL;
+ALTER TABLE agent_definition_output_limits ALTER COLUMN tenant_id SET NOT NULL;
+ALTER TABLE agent_definition_output_limits ENABLE ROW LEVEL SECURITY;
+ALTER TABLE agent_definition_output_limits FORCE ROW LEVEL SECURITY;
+CREATE POLICY agent_definition_output_limits_tenant_policy
+  ON agent_definition_output_limits
+  USING (tenant_id = current_setting('coreloom.tenant_id', true))
+  WITH CHECK (tenant_id = current_setting('coreloom.tenant_id', true));
+
+ALTER TABLE agent_run_execution_limits ADD COLUMN tenant_id TEXT;
+UPDATE agent_run_execution_limits AS child
+SET tenant_id = parent.tenant_id
+FROM agent_runs AS parent
+WHERE parent.id = child.run_id AND child.tenant_id IS NULL;
+DELETE FROM agent_run_execution_limits WHERE tenant_id IS NULL;
+ALTER TABLE agent_run_execution_limits ALTER COLUMN tenant_id SET NOT NULL;
+ALTER TABLE agent_run_execution_limits ENABLE ROW LEVEL SECURITY;
+ALTER TABLE agent_run_execution_limits FORCE ROW LEVEL SECURITY;
+CREATE POLICY agent_run_execution_limits_tenant_policy
+  ON agent_run_execution_limits
+  USING (tenant_id = current_setting('coreloom.tenant_id', true))
+  WITH CHECK (tenant_id = current_setting('coreloom.tenant_id', true));
+
+ALTER TABLE agent_run_output_limits ADD COLUMN tenant_id TEXT;
+UPDATE agent_run_output_limits AS child
+SET tenant_id = parent.tenant_id
+FROM agent_runs AS parent
+WHERE parent.id = child.run_id AND child.tenant_id IS NULL;
+DELETE FROM agent_run_output_limits WHERE tenant_id IS NULL;
+ALTER TABLE agent_run_output_limits ALTER COLUMN tenant_id SET NOT NULL;
+ALTER TABLE agent_run_output_limits ENABLE ROW LEVEL SECURITY;
+ALTER TABLE agent_run_output_limits FORCE ROW LEVEL SECURITY;
+CREATE POLICY agent_run_output_limits_tenant_policy
+  ON agent_run_output_limits
+  USING (tenant_id = current_setting('coreloom.tenant_id', true))
+  WITH CHECK (tenant_id = current_setting('coreloom.tenant_id', true));
+
+ALTER TABLE agent_run_skill_snapshots ADD COLUMN tenant_id TEXT;
+UPDATE agent_run_skill_snapshots AS child
+SET tenant_id = parent.tenant_id
+FROM agent_runs AS parent
+WHERE parent.id = child.run_id AND child.tenant_id IS NULL;
+DELETE FROM agent_run_skill_snapshots WHERE tenant_id IS NULL;
+ALTER TABLE agent_run_skill_snapshots ALTER COLUMN tenant_id SET NOT NULL;
+ALTER TABLE agent_run_skill_snapshots ENABLE ROW LEVEL SECURITY;
+ALTER TABLE agent_run_skill_snapshots FORCE ROW LEVEL SECURITY;
+CREATE POLICY agent_run_skill_snapshots_tenant_policy
+  ON agent_run_skill_snapshots
+  USING (tenant_id = current_setting('coreloom.tenant_id', true))
+  WITH CHECK (tenant_id = current_setting('coreloom.tenant_id', true));
+
+ALTER TABLE agent_provider_model_readiness ADD COLUMN tenant_id TEXT;
+UPDATE agent_provider_model_readiness AS child
+SET tenant_id = parent.tenant_id
+FROM agent_provider_connections AS parent
+WHERE parent.id = child.provider_id AND child.tenant_id IS NULL;
+DELETE FROM agent_provider_model_readiness WHERE tenant_id IS NULL;
+ALTER TABLE agent_provider_model_readiness ALTER COLUMN tenant_id SET NOT NULL;
+ALTER TABLE agent_provider_model_readiness ENABLE ROW LEVEL SECURITY;
+ALTER TABLE agent_provider_model_readiness FORCE ROW LEVEL SECURITY;
+CREATE POLICY agent_provider_model_readiness_tenant_policy
+  ON agent_provider_model_readiness
+  USING (tenant_id = current_setting('coreloom.tenant_id', true))
+  WITH CHECK (tenant_id = current_setting('coreloom.tenant_id', true));

package/modules/agents/migrations/0019_background_recovery_grants.down.sql

@@ -0,0 +1,6 @@
+REVOKE SELECT (id, tenant_id, status, queued_at, lease_expires_at)
+  ON agent_action_invocations FROM coreloom_background;
+DROP POLICY agent_action_invocations_background_policy ON agent_action_invocations;
+REVOKE SELECT (id, tenant_id, status, queued_at, lease_expires_at)
+  ON agent_runs FROM coreloom_background;
+DROP POLICY agent_runs_background_policy ON agent_runs;

package/modules/agents/migrations/0019_background_recovery_grants.up.sql

@@ -0,0 +1,17 @@
+-- The worker recovery polls have to find interrupted work before they know
+-- whose it is, so they read on the background role. That role gets no table
+-- privilege by default: each table it may poll grants the routing columns it
+-- needs and nothing else, under a policy of its own. Every claim that follows
+-- runs on the tenant-scoped runtime role, under the tenant the row named.
+CREATE POLICY agent_runs_background_policy ON agent_runs
+  FOR SELECT TO coreloom_background
+  USING (true);
+REVOKE SELECT ON agent_runs FROM coreloom_background;
+GRANT SELECT (id, tenant_id, status, queued_at, lease_expires_at)
+  ON agent_runs TO coreloom_background;
+CREATE POLICY agent_action_invocations_background_policy ON agent_action_invocations
+  FOR SELECT TO coreloom_background
+  USING (true);
+REVOKE SELECT ON agent_action_invocations FROM coreloom_background;
+GRANT SELECT (id, tenant_id, status, queued_at, lease_expires_at)
+  ON agent_action_invocations TO coreloom_background;

package/modules/agents/migrations/0020_provider_summary_role.down.sql

@@ -0,0 +1,2 @@
+REVOKE SELECT (id, enabled) ON agent_provider_connections FROM coreloom_background;
+DROP POLICY IF EXISTS agent_provider_connections_background_policy ON agent_provider_connections;

package/modules/agents/migrations/0020_provider_summary_role.up.sql

@@ -0,0 +1,17 @@
+-- The operator status command counts provider connections across the whole
+-- deployment, which the tenant-scoped runtime role cannot do and should not.
+-- It reads the one flag the count needs, under a policy of this table's own,
+-- and never sees a name, a base URL or an encrypted credential.
+DO $$
+BEGIN
+  IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'coreloom_background') THEN
+    RAISE EXCEPTION 'The coreloom_background role must exist before this migration.';
+  END IF;
+END
+$$;
+CREATE POLICY agent_provider_connections_background_policy
+  ON agent_provider_connections
+  FOR SELECT TO coreloom_background
+  USING (true);
+REVOKE SELECT ON agent_provider_connections FROM coreloom_background;
+GRANT SELECT (id, enabled) ON agent_provider_connections TO coreloom_background;

package/modules/agents/migrations/0021_agents_agent_reconciliation_role.down.sql

@@ -0,0 +1,4 @@
+REVOKE SELECT (tenant_id) ON agent_definitions FROM coreloom_background;
+DROP POLICY agent_definitions_reconciliation_policy ON agent_definitions;
+REVOKE SELECT (tenant_id, agent_id) ON module_agent_bindings FROM coreloom_background;
+DROP POLICY module_agent_bindings_reconciliation_policy ON module_agent_bindings;

package/modules/agents/migrations/0021_agents_agent_reconciliation_role.up.sql

@@ -0,0 +1,7 @@
+-- Discover only tenant routing keys; boot-time writes still use tenant transactions.
+CREATE POLICY agent_definitions_reconciliation_policy ON agent_definitions
+  FOR SELECT TO coreloom_background USING (true);
+GRANT SELECT (tenant_id) ON agent_definitions TO coreloom_background;
+CREATE POLICY module_agent_bindings_reconciliation_policy ON module_agent_bindings
+  FOR SELECT TO coreloom_background USING (true);
+GRANT SELECT (tenant_id, agent_id) ON module_agent_bindings TO coreloom_background;

package/modules/agents/migrations/README.md

@@ -0,0 +1,39 @@
+# Agentic core migrations
+
+`0001_agents_core.up.sql` owns tenant-scoped agent definitions, durable runs,
+execution events, leases, and the module audit hash chain. The matching down
+migration is destructive and exists for controlled local rollback only.
+
+`0012` adds run-cost accounting and backfills tokens for runs that completed
+before it landed. Those rows stay unpriced, because the price a run was billed
+at is not recoverable after the fact.
+
+`0009` adopts the pre-ledger v3 audit projection created by the former
+automation subsystem. Its exact table and index fingerprints and its complete
+v2 row copy are checked before adoption.
+
+`0013` retains every agent definition revision as an immutable executable
+snapshot, adds workflow-bound run output contracts, and introduces the durable
+versioned action queue.
+
+`0014` moves audit writes to v4, whose subject constraint covers both the
+historical schedule and trigger events and workflow action invocations. It
+copies the existing v3 chain byte for byte.
+
+`0015` persists the full normalized actor beside each run. Pre-existing rows
+retain their historical requester id as a user actor because the old schema did
+not record enough provenance to infer an agent run or a service configurator.
+
+`0016` stores module-owned business-agent definitions, tenant execution
+bindings, and the immutable ownership lineage of executable revisions. Module
+definitions remain after a module disappears so completed runs and workflow
+references retain their evidence.
+
+`0017` stores the delegated user separately from the run or action audit actor.
+Workers use that user for live authorization, while audit and record history
+continue to attribute work to the actual service or business agent.
+
+`0019` grants the background role the routing columns of `agent_runs` and
+`agent_action_invocations` under a SELECT policy of its own. The recovery polls
+have to find interrupted work before they know whose it is; every claim that
+follows runs on the tenant-scoped runtime role, under the tenant the row named.

package/modules/agents/module.json

@@ -0,0 +1,38 @@
+{
+	"$schema": "../../packages/contracts/schemas/module.schema.json",
+	"schemaVersion": 1,
+	"id": "agents.core",
+	"package": "@flowdular/module-agents",
+	"version": "0.9.1",
+	"profile": "full",
+	"capabilities": [
+		"api",
+		"database",
+		"client",
+		"translations",
+		"integration",
+		"cli"
+	],
+	"platform": {
+		"server": true,
+		"client": true
+	},
+	"dependencies": [
+		{
+			"id": "system.core",
+			"range": "0.5.0"
+		},
+		{
+			"id": "auth.core",
+			"range": "0.10.0"
+		}
+	],
+	"tenancy": "required",
+	"locales": ["en", "pl"],
+	"stability": "experimental",
+	"cli": {
+		"catalog": "src/cli/commands.json",
+		"entry": "src/cli/index.ts"
+	},
+	"platformApi": "0.1.0"
+}