@opengeni/db 6.0.0 → 6.0.1

package/drizzle/0503_session_meaningful_attention.sql

@@ -0,0 +1,81 @@
+-- deployment-mode: maintenance
+-- Old attention writers do not preserve explicit unread intent. Drain them;
+-- do not restart pre-0503 API/control/turn workers after this migration.
+SET LOCAL lock_timeout = '5s';
+SET LOCAL statement_timeout = '5min';
+DO $drain$
+DECLARE roles jsonb := nullif(current_setting('opengeni.migration_application_roles', true), '')::jsonb;
+BEGIN
+  IF roles IS NULL OR jsonb_typeof(roles) <> 'array' OR jsonb_array_length(roles) NOT BETWEEN 1 AND 16
+    OR EXISTS (SELECT 1 FROM jsonb_array_elements(roles) item WHERE jsonb_typeof(item) <> 'string'
+      OR btrim(item #>> '{}') = '' OR item #>> '{}' <> btrim(item #>> '{}') OR octet_length(item #>> '{}') > 63)
+    OR EXISTS (SELECT 1 FROM pg_stat_activity a JOIN jsonb_array_elements_text(roles) r ON r = a.usename
+      WHERE a.datname = current_database() AND a.pid <> pg_backend_pid()) THEN
+    RAISE EXCEPTION 'meaningful attention migration requires stopped application roles' USING ERRCODE = '55000';
+  END IF;
+END $drain$;
+
+ALTER TABLE session_pins ADD COLUMN manually_unread_through integer;
+
+-- One reverse probe per rail/tree row; raw deltas and housekeeping never enter
+-- this index. Keep the predicate aligned with session-meaningful-events.ts.
+CREATE INDEX session_events_meaningful_attention_idx
+ON session_events (workspace_id, session_id, sequence)
+WHERE type IN (
+  'agent.message.completed', 'turn.completed', 'turn.failed',
+  'session.requiresAction', 'session.humanInput.requested',
+  'tool.auth_needed', 'credential.auth_needed', 'goal.completed', 'goal.paused',
+  'goal.progress', 'goal.rewrite.proposed', 'rig.setup.failed',
+  'sandbox.operation.failed', 'sandbox.box.lost', 'workspace.revision.degraded',
+  'machine.op.failed', 'machine.link.lost', 'session.event.envelope_omitted'
+)
+AND duplicate_of_event_id IS NULL
+AND (turn_association IS NULL OR turn_association = 'current')
+AND (type <> 'agent.message.completed' OR coalesce(payload ->> 'text', '') <> '')
+AND (type <> 'turn.completed' OR (
+  NOT (payload ?| array['maintenance', 'segmentLimit'])
+  AND coalesce(nullif(payload -> 'output', 'null'::jsonb), payload -> 'result') IS NOT NULL
+  AND coalesce(nullif(payload -> 'output', 'null'::jsonb), payload -> 'result') NOT IN ('null'::jsonb, '""'::jsonb)
+));
+
+-- Historical attention_version does not distinguish mark-unread from mark-read
+-- or follow-up intent. Protect human-touched rows only if meaningful content is
+-- still unread (or the explicit empty-session sentinel is present). Reading a
+-- final followed by cleanup must NOT acquire a fabricated manual-unread fence.
+-- The raw migration frontier conservatively dates ambiguous surviving intent;
+-- only genuinely newer consumed work or explicit mark-read removes it.
+-- No acknowledged cursor is advanced and no subject is inferred.
+ALTER TABLE session_pins NO FORCE ROW LEVEL SECURITY;
+ALTER TABLE session_event_cursors NO FORCE ROW LEVEL SECURITY;
+ALTER TABLE session_events NO FORCE ROW LEVEL SECURITY;
+UPDATE session_pins personal SET manually_unread_through = cursor.last_sequence
+FROM session_event_cursors cursor
+WHERE cursor.account_id = personal.account_id
+  AND cursor.workspace_id = personal.workspace_id
+  AND cursor.session_id = personal.session_id
+  AND personal.attention_version > 0
+  AND (personal.acknowledged_sequence < 0 OR EXISTS (
+    SELECT 1 FROM session_events meaningful
+    WHERE meaningful.workspace_id = personal.workspace_id
+      AND meaningful.session_id = personal.session_id
+      AND meaningful.sequence > personal.acknowledged_sequence
+      AND meaningful.type IN (
+        'agent.message.completed', 'turn.completed', 'turn.failed',
+        'session.requiresAction', 'session.humanInput.requested',
+        'tool.auth_needed', 'credential.auth_needed', 'goal.completed', 'goal.paused',
+        'goal.progress', 'goal.rewrite.proposed', 'rig.setup.failed',
+        'sandbox.operation.failed', 'sandbox.box.lost', 'workspace.revision.degraded',
+        'machine.op.failed', 'machine.link.lost', 'session.event.envelope_omitted'
+      )
+      AND meaningful.duplicate_of_event_id IS NULL
+      AND (meaningful.turn_association IS NULL OR meaningful.turn_association = 'current')
+      AND (meaningful.type <> 'agent.message.completed' OR coalesce(meaningful.payload ->> 'text', '') <> '')
+      AND (meaningful.type <> 'turn.completed' OR (
+        NOT (meaningful.payload ?| array['maintenance', 'segmentLimit'])
+        AND coalesce(nullif(meaningful.payload -> 'output', 'null'::jsonb), meaningful.payload -> 'result') IS NOT NULL
+        AND coalesce(nullif(meaningful.payload -> 'output', 'null'::jsonb), meaningful.payload -> 'result') NOT IN ('null'::jsonb, '""'::jsonb)
+      ))
+  ));
+ALTER TABLE session_events FORCE ROW LEVEL SECURITY;
+ALTER TABLE session_event_cursors FORCE ROW LEVEL SECURITY;
+ALTER TABLE session_pins FORCE ROW LEVEL SECURITY;

package/drizzle/0504_skill_folder_limits.sql

@@ -0,0 +1,26 @@
+-- deployment-mode: rolling
+-- Widen admission only; preserve immutable content and all path/authority checks.
+SET LOCAL lock_timeout = '5s';
+SET LOCAL statement_timeout = '1min';
+DO $limits$
+DECLARE definition text; pair text[];
+BEGIN
+  definition := pg_get_functiondef('skill_files_valid(jsonb)'::regprocedure);
+  FOREACH pair SLICE 1 IN ARRAY ARRAY[
+    ['BETWEEN 1 AND 128','BETWEEN 1 AND 1024'],
+    ['bytes > 262144','bytes > 2097152'],
+    ['total <= 1048576','total <= 8388608']
+  ] LOOP
+    IF (length(definition)-length(replace(definition,pair[1],'')))/length(pair[1])<>1 THEN
+      RAISE EXCEPTION 'Skill limit validator anchor mismatch: %',pair[1];
+    END IF;
+    definition:=replace(definition,pair[1],pair[2]);
+  END LOOP;
+  EXECUTE definition;
+END $limits$;
+ALTER TABLE preference_registry_revisions DROP CONSTRAINT preference_registry_revisions_text_chk;
+ALTER TABLE preference_registry_revisions ADD CONSTRAINT preference_registry_revisions_text_chk CHECK (
+  length(btrim(title)) BETWEEN 1 AND 120
+  AND length(btrim(description)) BETWEEN 1 AND 1024
+  AND length(btrim(content)) > 0 AND length(content) <= 2097152
+);

package/drizzle/0505_workspace_control_revision_frontier.sql

@@ -0,0 +1,37 @@
+-- deployment-mode: rolling
+-- Repair a regressed control head without replaying historical pause/resume
+-- actions. Revisions are cursors: advancing the head changes no control state.
+SET LOCAL lock_timeout = '5s';
+SET LOCAL statement_timeout = '1min';
+
+-- Lock the control head before the event ledger, matching control writers.
+ALTER TABLE workspace_inference_controls NO FORCE ROW LEVEL SECURITY;
+ALTER TABLE workspace_control_events NO FORCE ROW LEVEL SECURITY;
+
+UPDATE workspace_inference_controls AS control
+SET revision = frontier.revision
+FROM (
+  SELECT workspace_id, max(revision) AS revision
+  FROM workspace_control_events
+  GROUP BY workspace_id
+) AS frontier
+WHERE control.workspace_id = frontier.workspace_id
+  AND control.revision < frontier.revision;
+
+CREATE FUNCTION opengeni_private.prevent_workspace_control_revision_rollback()
+RETURNS trigger LANGUAGE plpgsql AS $$
+BEGIN
+  IF NEW.revision < OLD.revision THEN
+    RAISE EXCEPTION 'workspace control revision cannot move backwards'
+      USING ERRCODE = '23514';
+  END IF;
+  RETURN NEW;
+END;
+$$;
+REVOKE ALL ON FUNCTION opengeni_private.prevent_workspace_control_revision_rollback() FROM PUBLIC;
+CREATE TRIGGER workspace_control_revision_monotonic
+BEFORE UPDATE OF revision ON workspace_inference_controls
+FOR EACH ROW EXECUTE FUNCTION opengeni_private.prevent_workspace_control_revision_rollback();
+
+ALTER TABLE workspace_control_events FORCE ROW LEVEL SECURITY;
+ALTER TABLE workspace_inference_controls FORCE ROW LEVEL SECURITY;

package/drizzle/0506_background_command_text.sql

@@ -0,0 +1,3 @@
+-- deployment-mode: rolling
+-- Existing rows retain their preview; new registrations preserve original text.
+ALTER TABLE session_background_commands ADD COLUMN command_text text;

package/drizzle/0507_integration_oauth_pending_states.sql

@@ -0,0 +1,27 @@
+-- deployment-mode: rolling
+-- Keep MCP OAuth callback context server-side; provider-facing state is a short reference.
+CREATE TABLE integration_oauth_pending_states (
+  id uuid PRIMARY KEY,
+  account_id uuid NOT NULL REFERENCES managed_accounts(id) ON DELETE CASCADE,
+  workspace_id uuid NOT NULL,
+  state_encrypted text NOT NULL CHECK (octet_length(state_encrypted) BETWEEN 1 AND 32768),
+  expires_at timestamptz NOT NULL,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  CONSTRAINT integration_oauth_pending_states_workspace_account_fk
+    FOREIGN KEY (workspace_id, account_id) REFERENCES workspaces(id, account_id) ON DELETE CASCADE
+);
+CREATE INDEX integration_oauth_pending_states_expiry_idx
+  ON integration_oauth_pending_states (workspace_id, expires_at);
+ALTER TABLE integration_oauth_pending_states ENABLE ROW LEVEL SECURITY;
+ALTER TABLE integration_oauth_pending_states FORCE ROW LEVEL SECURITY;
+CREATE POLICY integration_oauth_pending_states_workspace_scope
+  ON integration_oauth_pending_states
+  USING (opengeni_private.workspace_rls_visible(account_id, workspace_id))
+  WITH CHECK (opengeni_private.workspace_rls_visible(account_id, workspace_id));
+REVOKE ALL ON TABLE integration_oauth_pending_states FROM PUBLIC;
+DO $$
+BEGIN
+  IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'opengeni_app') THEN
+    GRANT SELECT, INSERT, UPDATE, DELETE ON integration_oauth_pending_states TO opengeni_app;
+  END IF;
+END $$;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/db",
-  "version": "6.0.0",
+  "version": "6.0.1",
   "description": "OpenGeni persistence: Drizzle schema, RLS-scoped query layer, the SQL migration runner, and role provisioning.",
   "license": "Apache-2.0",
   "repository": {
@@ -114,10 +114,10 @@
     "prepublishOnly": "bash ../../scripts/prepublish-guard"
   },
   "dependencies": {
-    "@opengeni/codemode": "^0.6.0",
-    "@opengeni/codex": "^0.2.24",
-    "@opengeni/config": "^2.0.0",
-    "@opengeni/contracts": "^5.0.0",
+    "@opengeni/codemode": "^0.6.1",
+    "@opengeni/codex": "^0.2.25",
+    "@opengeni/config": "^2.1.0",
+    "@opengeni/contracts": "^5.1.0",
     "@opengeni/network": "^0.3.1",
     "drizzle-orm": "^0.45.2",
     "postgres": "^3.4.7"

package/src/child-read-reconciliation.ts

@@ -0,0 +1,170 @@
+import { isDeepStrictEqual } from "node:util";
+import { fromPostgresLosslessJson } from "./lossless-json";
+
+/** Decode a stored row exactly once, by its own out-of-band version. Removing
+ * the version at this boundary prevents literal marker text being decoded again
+ * after the logical payload is placed inside a separately versioned receipt. */
+export function logicalChildReadEvent<
+  T extends { payload: unknown; payloadCodecVersion: number | null },
+>(row: T): Omit<T, "payloadCodecVersion"> {
+  const { payloadCodecVersion, ...event } = row;
+  return { ...event, payload: fromPostgresLosslessJson(row.payload, payloadCodecVersion) };
+}
+
+/** Rows arrive newest first from the bounded indexed query. Budget what the
+ * parent actually reads, not the PostgreSQL string compatibility encoding. */
+export function boundedChildLifecycleEvidence(
+  rows: readonly {
+    sequence: number;
+    type: string;
+    payload: unknown;
+    payloadCodecVersion: number | null;
+  }[],
+): Array<{ sequence: number; type: string; payload: unknown }> {
+  const evidence: Array<{ sequence: number; type: string; payload: unknown }> = [];
+  let bytes = 0;
+  for (const row of rows.slice(0, 32)) {
+    const { sequence, type, payload } = logicalChildReadEvent(row);
+    const candidate = { sequence, type, payload };
+    const size = Buffer.byteLength(JSON.stringify(candidate), "utf8");
+    if (bytes + size > 8192) continue;
+    evidence.push(candidate);
+    bytes += size;
+  }
+  return evidence.reverse();
+}
+
+type RecordValue = Record<string, unknown>;
+const record = (value: unknown): RecordValue | null =>
+  value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as RecordValue)
+    : null;
+
+/** Historical tool output is a potentially lossy audit lane. Accept only known
+ * complete envelopes, then compare each returned item with its retained source.
+ * Tool names, cursors and terminal status are never content evidence alone. */
+export function historicalChildReadItems(
+  name: unknown,
+  argsValue: unknown,
+  outputValue: unknown,
+): Array<{ sessionId: string; item: RecordValue; view: string }> {
+  const decode = (value: unknown): unknown => {
+    if (typeof value !== "string") return value;
+    if (Buffer.byteLength(value) > 256 * 1024) return null;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return null;
+    }
+  };
+  const args = record(decode(argsValue));
+  let output = decode(outputValue);
+  const envelope = record(output);
+  if (envelope?.isError === true) return [];
+  const content = envelope?.content ?? (Array.isArray(output) ? output : null);
+  if (content !== null) {
+    if (!Array.isArray(content) || content.length !== 1) return [];
+    const text = record(content[0]);
+    if (text?.type !== "text") return [];
+    output = decode(text.text);
+  }
+  const page = record(output);
+  if (
+    !args ||
+    !page ||
+    page.truncated === true ||
+    record(page.truncation)?.truncated === true ||
+    page.sourceExact === false
+  )
+    return [];
+  if (name === "opengeni__session_wait") {
+    if (page.aborted === true || !Array.isArray(page.changed) || !Array.isArray(args.targets))
+      return [];
+    const targets = new Set(args.targets.map((target) => record(target)?.sessionId));
+    return page.changed.flatMap((value) => {
+      const target = record(value);
+      if (
+        !target ||
+        typeof target.sessionId !== "string" ||
+        !targets.has(target.sessionId) ||
+        !Array.isArray(target.events)
+      )
+        return [];
+      return target.events.flatMap((eventValue) => {
+        const item = record(eventValue);
+        return item ? [{ sessionId: target.sessionId as string, item, view: "wait" }] : [];
+      });
+    });
+  }
+  if (name !== "opengeni__session_events" || typeof args.sessionId !== "string") return [];
+  if (Array.isArray(page.events)) {
+    const view =
+      page.view === "conversation" || page.view === "results"
+        ? page.view
+        : page.payloadMode === "full"
+          ? "debug"
+          : null;
+    if (!view || (view !== "debug" && page.sourceExact !== true)) return [];
+    return page.events.flatMap((value) => {
+      const item = record(value);
+      const fragment = record(item?.fragment);
+      if (
+        !item ||
+        item.sourceOmitted ||
+        (item.fragment !== undefined &&
+          (!fragment || fragment.offset !== 0 || fragment.complete !== true))
+      )
+        return [];
+      return [{ sessionId: args.sessionId as string, item, view }];
+    });
+  }
+  if (page.version === 1 && record(page.truncation)?.truncated === false) {
+    return [{ sessionId: args.sessionId, item: page, view: "compact" }];
+  }
+  return [];
+}
+
+export function historicalChildReadMatches(
+  candidate: ReturnType<typeof historicalChildReadItems>[number],
+  event: { id: string; sequence: number; type: string; payload: unknown },
+): boolean {
+  const { item, view } = candidate;
+  const retained = record(event.payload);
+  if (record(retained?.truncation)?.truncated === true || retained?.sourceOmitted === true)
+    return false;
+  if (
+    item.sequence !== event.sequence ||
+    (item.id !== undefined && item.id !== event.id) ||
+    (item.type !== undefined && item.type !== event.type)
+  )
+    return false;
+  if (view === "debug") return isDeepStrictEqual(item.payload, event.payload);
+  const payload = record(event.payload);
+  if (!payload) return false;
+  if (view === "conversation") {
+    return (
+      event.type === "agent.message.completed" &&
+      typeof payload.text === "string" &&
+      item.text === payload.text
+    );
+  }
+  if (view === "results") {
+    const value = event.type === "turn.completed" ? (payload.output ?? payload.result) : payload;
+    return (
+      value !== undefined &&
+      item.text === (typeof value === "string" ? value : JSON.stringify(value))
+    );
+  }
+  // Compact/wait summaries cannot prove that omitted questions, errors or goal
+  // fields were consumed. Restrict historical reconciliation to exact answers.
+  if (event.type !== "turn.completed" && event.type !== "agent.message.completed") return false;
+  const answer =
+    event.type === "turn.completed" ? (payload.output ?? payload.result) : payload.text;
+  return (
+    typeof answer === "string" &&
+    answer.length > 0 &&
+    (item.text === answer ||
+      item.result === answer ||
+      (view === "compact" && item.output === answer))
+  );
+}