@stackbone/cli 0.6.3 → 0.7.0

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/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.3",
+  "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",