@stackbone/cli 0.6.2 → 0.7.0

package/migrations/0094_rag_document_versions.sql

@@ -0,0 +1,61 @@
+-- 0094_rag_document_versions.sql — RAG document versions (STA3-8)
+-- Every version of a document is its own row, with its own `source` (its storage
+-- key) and its own chunks, so rollback flips a flag and re-embeds nothing. The
+-- versions of one document share a `document_key`; the agent reads only the
+-- `is_active` one.
+--
+-- A document that existed before this is its own version 1, published, keyed by
+-- its `source`.
+
+ALTER TABLE stackbone_platform.rag_documents
+ADD COLUMN IF NOT EXISTS document_key text,
+ADD COLUMN IF NOT EXISTS version integer NOT NULL DEFAULT 1,
+ADD COLUMN IF NOT EXISTS is_active boolean NOT NULL DEFAULT true;
+
+-- Two overlapping ingests of one source could leave two rows before PLA-2327's
+-- lock. The newest keeps the source as its key; the older ones become documents
+-- of their own, still published, so nothing the agent reads changes and the
+-- unique index below can build. Deleting them would lose data.
+UPDATE stackbone_platform.rag_documents d
+SET document_key = CASE WHEN ranked.rn = 1 THEN d.source ELSE d.source || '#' || d.id END
+FROM (
+  SELECT id, row_number() OVER (
+    PARTITION BY collection_id, source ORDER BY created_at DESC, id DESC
+  ) AS rn
+  FROM stackbone_platform.rag_documents
+  WHERE document_key IS NULL
+) ranked
+WHERE d.id = ranked.id;
+
+-- Postgres cannot default one column to another. A workspace on an SDK older
+-- than this migration inserts without the key, so the trigger fills it in
+-- instead of failing every ingest on NOT NULL.
+CREATE OR REPLACE FUNCTION stackbone_platform.rag_documents_default_key()
+RETURNS trigger
+LANGUAGE plpgsql
+AS $$
+BEGIN
+  NEW.document_key := COALESCE(NEW.document_key, NEW.source);
+  RETURN NEW;
+END;
+$$;
+
+DROP TRIGGER IF EXISTS rag_documents_default_key ON stackbone_platform.rag_documents;
+CREATE TRIGGER rag_documents_default_key
+BEFORE INSERT ON stackbone_platform.rag_documents
+FOR EACH ROW EXECUTE FUNCTION stackbone_platform.rag_documents_default_key();
+
+ALTER TABLE stackbone_platform.rag_documents
+ALTER COLUMN document_key SET NOT NULL;
+
+-- At most one published version per document. Non-deferrable, so publishing is
+-- two statements (unpublish the siblings, then publish the target): one swapping
+-- UPDATE can reach the target before the sibling and fail on the check.
+CREATE UNIQUE INDEX IF NOT EXISTS rag_documents_active_key_uq
+ON stackbone_platform.rag_documents (collection_id, document_key)
+WHERE is_active;
+
+-- Covers unpublished versions too: a writer that misses the key lock and hands
+-- out a version number twice fails here instead of leaving two v2s behind.
+CREATE UNIQUE INDEX IF NOT EXISTS rag_documents_key_version_uq
+ON stackbone_platform.rag_documents (collection_id, document_key, version);

package/migrations/0095_rag_document_version_counters.sql

@@ -0,0 +1,22 @@
+-- 0095_rag_document_version_counters.sql — a version number is never reused (STA3-8 D11)
+-- The last version number each document handed out. Numbering from the rows
+-- left (`max(version) + 1`) gave a deleted draft's number to the next upload,
+-- and the activity log then showed "deleted v3" next to a live, different v3.
+-- A new version takes this counter or the rows' highest version, whichever is
+-- greater, plus one, under the document's key lock. Deleting the whole document
+-- drops its row; deleting one version leaves it alone.
+
+CREATE TABLE IF NOT EXISTS stackbone_platform.rag_document_version_counters (
+  collection_id uuid NOT NULL REFERENCES stackbone_platform.rag_collections (id) ON DELETE CASCADE,
+  document_key text NOT NULL,
+  last_version integer NOT NULL,
+  PRIMARY KEY (collection_id, document_key)
+);
+
+-- A document from before this starts from the highest version it still holds:
+-- a number deleted before 0095 cannot be told apart from one never handed out.
+INSERT INTO stackbone_platform.rag_document_version_counters (collection_id, document_key, last_version)
+SELECT collection_id, document_key, max(version)
+FROM stackbone_platform.rag_documents
+GROUP BY collection_id, document_key
+ON CONFLICT (collection_id, document_key) DO NOTHING;

package/migrations/0096_trigger_subscriptions_target_kind.sql

@@ -0,0 +1,29 @@
+-- 0096_trigger_subscriptions_target_kind.sql — a link's destination carries a kind (PLA-967)
+-- A connector trigger is about to start a deep agent as well as a workflow (PLA-951),
+-- and `workflow_name` (0021) gave the destination a name and no kind. The column
+-- becomes `target_name` beside a `target_kind`, the same pair `eval_suites` uses
+-- (0038). Every link that existed before reads as a workflow link through the default.
+--
+-- No CHECK on `target_kind`, as `eval_suites.target_kind` (0038) and `runs.entity_kind`
+-- (0037): a box running an older build must be able to store a kind it cannot run
+-- rather than reject the write. The register endpoint refuses what it cannot start.
+--
+-- `RENAME COLUMN` has no `IF EXISTS`, and a DBA who applies the platform SQL by hand
+-- (`STACKBONE_SKIP_MIGRATIONS=1`) can run it twice, so the rename is guarded on the
+-- old column still being there.
+
+DO $$
+BEGIN
+  IF EXISTS (
+    SELECT 1 FROM information_schema.columns
+     WHERE table_schema = 'stackbone_platform'
+       AND table_name = 'trigger_subscriptions'
+       AND column_name = 'workflow_name'
+  ) THEN
+    ALTER TABLE stackbone_platform.trigger_subscriptions
+      RENAME COLUMN workflow_name TO target_name;
+  END IF;
+END $$;
+
+ALTER TABLE stackbone_platform.trigger_subscriptions
+ADD COLUMN IF NOT EXISTS target_kind text NOT NULL DEFAULT 'workflow';

package/migrations/0097_voice_settings.sql

@@ -0,0 +1,34 @@
+-- 0096_voice_settings.sql — the voice settings an operator changed from Studio
+-- for one deep agent (FDE-62 S5).
+--
+-- A row holds ONLY the fields Studio changed, as one JSON object in the shape of
+-- `voiceSettingsSchema` (`@stackbone/validators`, `studio-voice.ts`): top-level
+-- leaves, the `vad` / `turn` / `interruptions` groups with only their changed
+-- leaves, `keyterms` whole, and `greeting: null` as a declared "wait for the
+-- caller". The box lays it over the agent's code and the box defaults leaf by
+-- leaf (Studio > code > box default, FDE-62 D2) each time it reads the agent or
+-- dispatches a call, so a saved change reaches the next call with nothing
+-- restarted.
+--
+-- Partial on purpose, never the full effective value: a leaf Studio did not
+-- touch keeps following the code, so a redeploy that changes it still lands.
+-- Resetting a field removes its leaf, and resetting the last one deletes the
+-- row, so "no row" means "nothing changed in Studio".
+--
+-- NO VERSIONS and no `updated_by`, unlike 0073: the activity log records who
+-- changed what and when, which is the history this table does not keep.
+--
+-- Identity is the deep agent's name alone. Only a deep agent takes a call, so
+-- there is no `owner_kind` beside it. `owner_name` is free text for the reason
+-- 0047 gives for a prompt's owner.
+--
+-- Deliberately NO CHECK on `overrides`, following 0073: a box running an older
+-- build must still be able to STORE what a newer one wrote, and the rules
+-- (bounds, the known model lists, the cross-field checks) change with the build.
+-- The route parses a body before it writes, and the merge
+-- (`resolveEffectiveVoiceSettings`) reads only the leaves its build knows.
+CREATE TABLE IF NOT EXISTS stackbone_platform.voice_settings (
+    owner_name  text        PRIMARY KEY,
+    overrides   jsonb       NOT NULL,
+    updated_at  timestamptz NOT NULL DEFAULT now()
+);

package/migrations/0098_model_selections_provider_id.sql

@@ -0,0 +1,23 @@
+-- 0098_model_selections_provider_id.sql — the provider an operator picked next
+-- to the model, for a box that runs more than one (STA3-17, decision D10).
+--
+-- Two providers may serve the same model id. A pick that names only the id is
+-- ambiguous there, so the pick also names the provider that serves it. The SDK
+-- composes `<providerId>::<modelId>` when it reads a pick; this column is where
+-- the provider half lives.
+--
+-- Its own column, not a `b::gpt-4o` string in `model_id`: every box reader of
+-- `model_id` would then have to split it (D10).
+--
+-- NULLABLE, with no default and no backfill. Every pick saved before this file
+-- named no provider, and "no provider" keeps today's resolution: the box sends
+-- the id to the one provider that serves it, or refuses it as ambiguous when two
+-- do. Free text with NO CHECK and no foreign key (providers live in system
+-- secrets, not a table), for the same reason 0073 has none on `model_id`: the
+-- provider may be removed while a pick still names it, and that fails at run
+-- time, not at write.
+--
+-- The PRIMARY KEY stays (owner_kind, owner_name, key): one pick per key, whatever
+-- provider serves it.
+ALTER TABLE stackbone_platform.model_selections
+    ADD COLUMN IF NOT EXISTS provider_id text;

package/migrations/0099_memory.sql

@@ -0,0 +1,35 @@
+-- 0099_memory.sql — per-person long-term facts and call history (FDE-68)
+-- Memory is platform-owned box state: it follows RAG into the
+-- stackbone_platform schema so every deployed workspace receives it.
+
+CREATE TABLE IF NOT EXISTS stackbone_platform.memory_calls (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  user_id text NOT NULL,
+  started_at timestamptz NOT NULL,
+  duration_seconds integer CHECK (duration_seconds >= 0),
+  outcome text CHECK (outcome IS NULL OR char_length(outcome) BETWEEN 1 AND 100),
+  summary text NOT NULL CHECK (char_length(summary) BETWEEN 1 AND 600),
+  created_at timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE INDEX IF NOT EXISTS memory_calls_user_started_idx
+  ON stackbone_platform.memory_calls (user_id, started_at DESC, created_at DESC);
+
+CREATE TABLE IF NOT EXISTS stackbone_platform.memory_facts (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  user_id text NOT NULL,
+  content text NOT NULL CHECK (char_length(content) BETWEEN 1 AND 500),
+  insertion_order bigint GENERATED ALWAYS AS IDENTITY NOT NULL,
+  created_call_id uuid REFERENCES stackbone_platform.memory_calls(id) ON DELETE SET NULL,
+  updated_call_id uuid REFERENCES stackbone_platform.memory_calls(id) ON DELETE SET NULL,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE INDEX IF NOT EXISTS memory_facts_user_idx
+  ON stackbone_platform.memory_facts (user_id);
+
+CREATE TABLE IF NOT EXISTS stackbone_platform.memory_user_revisions (
+  user_id text PRIMARY KEY,
+  revision bigint NOT NULL DEFAULT 0 CHECK (revision >= 0)
+);

package/migrations/0100_memory_call_run.sql

@@ -0,0 +1,9 @@
+-- A memory record keeps the run that owns the full transcript without copying
+-- transcript content into memory itself.
+
+ALTER TABLE stackbone_platform.memory_calls
+  ADD COLUMN IF NOT EXISTS run_id uuid
+  REFERENCES stackbone_platform.runs(id) ON DELETE SET NULL;
+
+CREATE INDEX IF NOT EXISTS memory_calls_run_idx
+  ON stackbone_platform.memory_calls (run_id);

package/migrations/0101_memory_call_run_no_fk.sql

@@ -0,0 +1,5 @@
+-- A run can be projected after its workflow has already stored memory, so the
+-- navigation link must accept a UUID before the corresponding run row exists.
+
+ALTER TABLE stackbone_platform.memory_calls
+  DROP CONSTRAINT IF EXISTS memory_calls_run_id_fkey;

package/migrations/0102_voice_recordings.sql

@@ -0,0 +1,31 @@
+-- 0097_voice_recordings.sql — the recording of each voice call (FDE-62 S12).
+--
+-- One row per ROOM, keyed on it: a room is one call (`POST /api/voice/rooms`
+-- opens a fresh `call-<agent>-<8 hex>` every time), and the box starts one
+-- room-composite egress for it. A session can hold several calls, so
+-- `session_id` is indexed, newest first, for the read Studio's session screen makes.
+--
+-- `storage_key` is relative to the agent's scope in the box bucket, the key the
+-- Storage Browser shows; the egress writes it under the `<agentId>/` prefix.
+--
+-- `egress_id` is LiveKit's id for the egress, null until LiveKit accepts the
+-- start. The status moves past `recording` lazily, when someone reads the row:
+-- the box asks LiveKit for that egress then, because no webhook can reach a dev
+-- box. A row still without one after the join window means the start never
+-- went through (the room was never joined, or the box restarted mid-retry).
+--
+-- Deliberately NO foreign key to `sessions`: the row is written when the room
+-- opens, and the call's first turn creates the session row later, the race 0019
+-- describes.
+CREATE TABLE IF NOT EXISTS stackbone_platform.voice_recordings (
+    room         text        PRIMARY KEY,
+    session_id   uuid        NOT NULL,
+    storage_key  text        NOT NULL,
+    status       text        NOT NULL CHECK (status IN ('recording', 'ready', 'failed')),
+    egress_id    text        NULL,
+    started_at   timestamptz NOT NULL DEFAULT now(),
+    ended_at     timestamptz NULL
+);
+
+CREATE INDEX IF NOT EXISTS voice_recordings_session_id_started_at_idx
+    ON stackbone_platform.voice_recordings (session_id, started_at DESC);

package/migrations/0103_rag_collection_embeddings.sql

@@ -0,0 +1,21 @@
+-- STA3-18: preserve the meaning of historical vectors and document versions
+-- while new collections can choose another provider, model and dimension.
+ALTER TABLE stackbone_platform.rag_collections
+  ADD COLUMN IF NOT EXISTS embedding_provider text NOT NULL DEFAULT 'default',
+  ADD COLUMN IF NOT EXISTS embedding_model text NOT NULL DEFAULT 'openai/text-embedding-3-small',
+  ADD COLUMN IF NOT EXISTS embedding_dimension integer NOT NULL DEFAULT 1536
+    CONSTRAINT rag_collections_embedding_dimension_check CHECK (embedding_dimension BETWEEN 1 AND 16000),
+  ADD COLUMN IF NOT EXISTS embedding_revision integer NOT NULL DEFAULT 1
+    CONSTRAINT rag_collections_embedding_revision_check CHECK (embedding_revision > 0),
+  ADD COLUMN IF NOT EXISTS embedding_state text NOT NULL DEFAULT 'ready'
+    CONSTRAINT rag_collections_embedding_state_check CHECK (embedding_state IN ('ready', 'rebuilding', 'failed')),
+  ADD CONSTRAINT rag_collections_embedding_identity_check
+    CHECK (length(trim(embedding_provider)) > 0 AND length(trim(embedding_model)) > 0);
+
+DROP INDEX IF EXISTS stackbone_platform.rag_chunks_embedding_hnsw;
+ALTER TABLE stackbone_platform.rag_chunks ALTER COLUMN embedding TYPE vector;
+
+-- Other dimensions are initialized under the shared index-creation lock.
+CREATE INDEX IF NOT EXISTS rag_chunks_embedding_1536_hnsw
+  ON stackbone_platform.rag_chunks USING hnsw ((embedding::vector(1536)) vector_cosine_ops)
+  WHERE vector_dims(embedding) = 1536;

package/migrations/0104_rag_collection_rebuilds.sql

@@ -0,0 +1,33 @@
+CREATE TABLE stackbone_platform.rag_collection_rebuilds (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  collection_id uuid NOT NULL REFERENCES stackbone_platform.rag_collections(id) ON DELETE CASCADE,
+  target_provider text NOT NULL CHECK (length(trim(target_provider)) > 0),
+  target_model text NOT NULL CHECK (length(trim(target_model)) > 0),
+  target_dimension integer NOT NULL CHECK (target_dimension BETWEEN 1 AND 16000),
+  target_revision integer NOT NULL CHECK (target_revision > 0),
+  attempt integer NOT NULL DEFAULT 1 CHECK (attempt > 0),
+  attempt_token uuid NOT NULL DEFAULT gen_random_uuid(),
+  status text NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'running', 'failed', 'succeeded')),
+  error text,
+  run_id text,
+  world_run_id text,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now(),
+  finished_at timestamptz,
+  UNIQUE (collection_id, target_revision)
+);
+CREATE UNIQUE INDEX rag_collection_rebuilds_active_collection_uq
+  ON stackbone_platform.rag_collection_rebuilds(collection_id)
+  WHERE status IN ('pending', 'running', 'failed');
+
+CREATE TABLE stackbone_platform.rag_collection_rebuild_items (
+  rebuild_id uuid NOT NULL REFERENCES stackbone_platform.rag_collection_rebuilds(id) ON DELETE CASCADE,
+  document_id uuid NOT NULL REFERENCES stackbone_platform.rag_documents(id) ON DELETE CASCADE,
+  ordinal integer NOT NULL CHECK (ordinal >= 0),
+  document_snapshot jsonb NOT NULL CHECK (jsonb_typeof(document_snapshot) = 'object'),
+  source_kind text NOT NULL CHECK (source_kind IN ('original', 'chunks')),
+  prepared_chunks jsonb NOT NULL CHECK (jsonb_typeof(prepared_chunks) = 'array' AND jsonb_array_length(prepared_chunks) > 0),
+  completed_at timestamptz,
+  PRIMARY KEY (rebuild_id, document_id),
+  UNIQUE (rebuild_id, ordinal)
+);

package/migrations/0105_rag_rebuild_manifest_size.sql

@@ -0,0 +1,15 @@
+-- Keep the original manifest size when a missing document cascades its item.
+ALTER TABLE stackbone_platform.rag_collection_rebuilds
+  ADD COLUMN manifest_size integer NOT NULL DEFAULT 0;
+
+UPDATE stackbone_platform.rag_collection_rebuilds r
+SET manifest_size = (
+  SELECT count(*)::integer FROM stackbone_platform.rag_collection_rebuild_items i
+  WHERE i.rebuild_id = r.id
+);
+
+ALTER TABLE stackbone_platform.rag_collection_rebuilds
+  ADD CONSTRAINT rag_collection_rebuilds_manifest_size_check CHECK (manifest_size >= 0);
+
+CREATE INDEX rag_collection_rebuild_items_document_idx
+  ON stackbone_platform.rag_collection_rebuild_items(document_id);

package/migrations/0106_memory_agent_scope.sql

@@ -0,0 +1,16 @@
+-- FDE-87: legacy rows have no reliable agent owner; the author approved erasure.
+DELETE FROM stackbone_platform.memory_facts;
+DELETE FROM stackbone_platform.memory_calls;
+DELETE FROM stackbone_platform.memory_user_revisions;
+
+ALTER TABLE stackbone_platform.memory_facts ADD COLUMN agent_id text NOT NULL;
+ALTER TABLE stackbone_platform.memory_calls ADD COLUMN agent_id text NOT NULL;
+ALTER TABLE stackbone_platform.memory_user_revisions ADD COLUMN agent_id text NOT NULL;
+ALTER TABLE stackbone_platform.memory_user_revisions DROP CONSTRAINT memory_user_revisions_pkey;
+ALTER TABLE stackbone_platform.memory_user_revisions ADD PRIMARY KEY (agent_id, user_id);
+
+DROP INDEX stackbone_platform.memory_facts_user_idx;
+CREATE INDEX memory_facts_user_idx ON stackbone_platform.memory_facts (agent_id, user_id);
+DROP INDEX stackbone_platform.memory_calls_user_started_idx;
+CREATE INDEX memory_calls_user_started_idx ON stackbone_platform.memory_calls
+  (agent_id, user_id, started_at DESC, created_at DESC);

package/migrations/0107_memory_settings.sql

@@ -0,0 +1,7 @@
+CREATE TABLE stackbone_platform.memory_settings (
+  agent_id text PRIMARY KEY,
+  overrides jsonb NOT NULL DEFAULT '{}'::jsonb,
+  updated_at timestamptz NOT NULL DEFAULT now(),
+  updated_by text,
+  CONSTRAINT memory_settings_overrides_object CHECK (jsonb_typeof(overrides) = 'object')
+);

package/migrations/0108_memory_identity_bindings.sql

@@ -0,0 +1,13 @@
+CREATE TABLE stackbone_platform.memory_identity_bindings (
+  agent_id text PRIMARY KEY,
+  identity_key text NOT NULL CHECK (char_length(identity_key) BETWEEN 1 AND 100),
+  source text NOT NULL CHECK (source IN ('code', 'studio', 'legacy')),
+  fixed_at timestamptz NOT NULL DEFAULT now()
+);
+
+INSERT INTO stackbone_platform.memory_identity_bindings (agent_id, identity_key, source)
+SELECT agent_id, 'customerId', 'legacy' FROM (
+  SELECT agent_id FROM stackbone_platform.memory_facts
+  UNION SELECT agent_id FROM stackbone_platform.memory_calls
+  UNION SELECT agent_id FROM stackbone_platform.memory_user_revisions
+) AS existing_agents;

package/migrations/0109_trigger_subscriptions_conversation_key.sql

@@ -0,0 +1,17 @@
+-- 0109_trigger_subscriptions_conversation_key.sql — an agent link's conversation key (PLA-971)
+-- A JSONata expression evaluated against each inbound event. Events that yield the
+-- same value continue one agent session; an event that yields nothing usable starts a
+-- fresh one. Nullable: NULL is "every event opens its own session", which every link
+-- that existed before reads as.
+--
+-- No CHECK tying it to `target_kind = 'agent'`, as `target_kind` itself (0096): a box
+-- running an older build must be able to store a row it cannot run rather than reject
+-- the write. The validators and the subscriptions router refuse a conversation key on
+-- a workflow link, and a correlation key on an agent link.
+--
+-- 0109 and not 0106: STA3-18 took 0103-0105, and open PR #785 (FDE-87) also claims
+-- 0103-0105 and has to renumber into 0106-0108. Gaps are legal
+-- (`scripts/check-migration-numbers.mjs`).
+
+ALTER TABLE stackbone_platform.trigger_subscriptions
+ADD COLUMN IF NOT EXISTS conversation_key text;

package/migrations/0110_concurrency_limits.sql

@@ -0,0 +1,52 @@
+-- 0110_concurrency_limits.sql — named concurrency limits for workflows.
+--
+-- A workflow takes a slot (`acquireSlot`) before it starts scarce work, and
+-- another workflow gives it back (`releaseSlot`) when that work ends. When no
+-- slot is free, the run waits on a World hook; the box resumes the hook when it
+-- grants a slot.
+--
+-- `concurrency_limiters`: one row per limit the workspace declares, synced from
+-- the manifest at boot. `capacity` and `max_hold` are what the code declares;
+-- `capacity_override` is what an operator saves in Studio, and wins when set.
+--
+-- `concurrency_slots`: one row per slot requested. `waiting` is in the queue,
+-- `granted` is given to the run but not yet confirmed by it, `held` is
+-- confirmed. Only `granted` and `held` count against the capacity.
+-- `claim_deadline` bounds how long a granted slot waits for its run to confirm;
+-- `expires_at` is the `max_hold` cut-off, after which the box takes the slot back.
+-- `hook_token` is UNIQUE so a retried enqueue step finds its row instead of
+-- queueing twice. `label` is an id the creator chooses, never personal data.
+--
+-- Every write locks the limiter row first (`SELECT ... FOR UPDATE`), then
+-- touches its slots: one lock order, so READ COMMITTED is enough.
+--
+-- Deliberately NO foreign key from `run_id` to `runs`: the run row is projected
+-- in the background by the run sweep and can land after the slot row.
+-- Deliberately NO foreign key from `limiter` to `concurrency_limiters` either:
+-- the boot sync keeps a limiter with slots, and the store refuses an unknown one.
+CREATE TABLE IF NOT EXISTS stackbone_platform.concurrency_limiters (
+    name               text        PRIMARY KEY,
+    capacity           integer     NOT NULL CHECK (capacity > 0),
+    max_hold           interval    NOT NULL,
+    capacity_override  integer     NULL CHECK (capacity_override > 0),
+    updated_at         timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE TABLE IF NOT EXISTS stackbone_platform.concurrency_slots (
+    id              uuid        PRIMARY KEY DEFAULT gen_random_uuid(),
+    limiter         text        NOT NULL,
+    state           text        NOT NULL CHECK (state IN ('waiting', 'granted', 'held')),
+    run_id          uuid        NULL,
+    hook_token      text        NOT NULL UNIQUE,
+    label           text        NULL,
+    enqueued_at     timestamptz NOT NULL DEFAULT now(),
+    granted_at      timestamptz NULL,
+    claim_deadline  timestamptz NULL,
+    expires_at      timestamptz NULL
+);
+
+CREATE INDEX IF NOT EXISTS concurrency_slots_limiter_state_enqueued_at_idx
+    ON stackbone_platform.concurrency_slots (limiter, state, enqueued_at);
+
+CREATE INDEX IF NOT EXISTS concurrency_slots_run_id_idx
+    ON stackbone_platform.concurrency_slots (run_id);

package/migrations/0111_concurrency_slots_now_idx.sql

@@ -0,0 +1,21 @@
+-- 0111_concurrency_slots_now_idx.sql — the indexes the Insights "now" metrics
+-- over concurrency slots are read through.
+--
+-- Two metrics read `concurrency_slots` (0110) on every query, never from a
+-- cache (the box runtime's `insights/engine/catalog/now-metrics.ts`):
+--
+--   - `slots_in_use`: slots `granted` or `held`, the ones that count against a
+--     limit's capacity, by `limiter`;
+--   - `slots_waiting`: slots `waiting` in the queue, by `limiter`.
+--
+-- As in 0086, each index is partial on the metric's predicate, spelled as the
+-- metric spells it so the planner proves the index covers the read, and holds
+-- the column its property reads, so a count by limit is an index-only scan over
+-- the rows the metric counts and no others.
+CREATE INDEX IF NOT EXISTS concurrency_slots_in_use_now_idx
+    ON stackbone_platform.concurrency_slots (limiter)
+    WHERE state IN ('granted', 'held');
+
+CREATE INDEX IF NOT EXISTS concurrency_slots_waiting_now_idx
+    ON stackbone_platform.concurrency_slots (limiter)
+    WHERE state = 'waiting';

package/migrations/0112_concurrency_max_hold_override.sql

@@ -0,0 +1,15 @@
+-- 0112_concurrency_max_hold_override.sql — an operator override for a limit's
+-- max hold, next to the capacity override 0110 already carries.
+--
+-- `max_hold` is what the code declares, synced from the manifest at boot;
+-- `max_hold_override` is what an operator saves in Studio or with
+-- `stackbone limits max-hold`, and wins when set. The boot sync never touches it.
+--
+-- The effective hold, `coalesce(max_hold_override, max_hold)`, is read once,
+-- when a slot is granted, and stamped into `concurrency_slots.expires_at`.
+-- Changing the override never rewrites `expires_at` of a slot already granted
+-- or held: lowering it does not take back running work, raising it does not
+-- extend a slot granted before the change.
+ALTER TABLE stackbone_platform.concurrency_limiters
+    ADD COLUMN IF NOT EXISTS max_hold_override interval NULL
+        CHECK (max_hold_override > interval '0');

package/migrations/0113_trigger_subscriptions_debounce_ms.sql

@@ -0,0 +1,13 @@
+-- 0113_trigger_subscriptions_debounce_ms.sql — an agent link's wait before it answers (STA3-25)
+-- Milliseconds the box waits after an event for more events of the same conversation,
+-- so a burst of chat messages from one customer gets one answer. Nullable: NULL is
+-- "answer each event as it arrives", which every link that existed before reads as.
+--
+-- No CHECK on the range or tying it to `target_kind = 'agent'` and a conversation key,
+-- as `conversation_key` (0109): a box running an older build must be able to store a
+-- row it cannot run rather than reject the write. The validators and the subscriptions
+-- router refuse a wait outside 1..10000, on a workflow link, and on an agent link
+-- without a conversation key.
+
+ALTER TABLE stackbone_platform.trigger_subscriptions
+ADD COLUMN IF NOT EXISTS debounce_ms integer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackbone/cli",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "license": "UNLICENSED",
   "type": "module",
   "bin": {
@@ -32,6 +32,7 @@
     "ioredis": "^5.10.1",
     "jose": "^6.2.3",
     "libsodium-wrappers": "^0.8.4",
+    "livekit-server-sdk": "2.19.1",
     "open": "^11.0.0",
     "openai": "^6.42.0",
     "pg": "^8.20.0",