@stackbone/cli 0.6.2 → 0.6.3

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackbone/cli",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "license": "UNLICENSED",
   "type": "module",
   "bin": {