@hotmeshio/long-tail 0.10.8 → 0.10.10

package/build/services/escalation/crud.js

@@ -74,6 +74,7 @@ async function createEscalation(input) {
         workflowName: escalation.workflow_type || '',
         taskQueue: escalation.task_queue || '',
         escalationId: escalation.id,
+        role: escalation.role,
         status: 'pending',
         data: { type: input.type, role: input.role },
     });
@@ -97,6 +98,7 @@ async function claimEscalation(id, userId, durationMinutes = 30) {
         workflowName: escalation.workflow_type || '',
         taskQueue: escalation.task_queue || '',
         escalationId: escalation.id,
+        role: escalation.role,
         status: 'claimed',
         data: { assigned_to: userId },
     });
@@ -137,6 +139,7 @@ async function resolveEscalation(id, resolverPayload, metadata, assertClaim, res
         workflowName: escalation.workflow_type || '',
         taskQueue: escalation.task_queue || '',
         escalationId: escalation.id,
+        role: escalation.role,
         status: 'resolved',
         data: {},
     });
@@ -170,6 +173,7 @@ async function resolveEscalationsByIds(ids, resolverPayload, metadata) {
             workflowName: escalation.workflow_type || '',
             taskQueue: escalation.task_queue || '',
             escalationId: escalation.id,
+            role: escalation.role,
             status: 'resolved',
             data: {},
         });
@@ -209,6 +213,7 @@ async function resolveEscalationsAllOrNone(items, metadata, assertAssignee, reso
             workflowName: escalation.workflow_type || '',
             taskQueue: escalation.task_queue || '',
             escalationId: escalation.id,
+            role: escalation.role,
             status: 'resolved',
             data: {},
         });
@@ -276,6 +281,7 @@ async function cancelEscalation(id) {
         workflowName: cancelled.workflow_type || '',
         taskQueue: cancelled.task_queue || '',
         escalationId: cancelled.id,
+        role: cancelled.role,
         status: 'cancelled',
         data: { reason: 'workflow_terminated' },
     });
@@ -335,6 +341,7 @@ async function releaseEscalation(id, userId) {
         workflowName: released.workflow_type || '',
         taskQueue: released.task_queue || '',
         escalationId: released.id,
+        role: released.role,
         status: 'released',
         data: { released_by: userId },
     });
@@ -358,8 +365,36 @@ async function releaseExpiredClaims() {
  */
 async function escalateToRole(id, targetRole) {
     const client = await (0, client_1.escalations)();
+    // The departing role is read before the move: the returned entry already
+    // carries the target role, and role-scoped subscribers of the OLD queue
+    // must see the item leave just as the new queue sees it arrive.
+    const before = await client.get(id);
+    const fromRole = before?.role ?? null;
     const entry = await client.escalateToRole({ id, targetRole });
-    return entry ? (0, map_1.toEscalationRecord)(entry) : null;
+    if (!entry)
+        return null;
+    const escalation = (0, map_1.toEscalationRecord)(entry);
+    // One reassignment, two subjects: the same event publishes under the
+    // departing role and the arriving role, so a subscriber scoped to either
+    // queue observes the move. `data` names both ends for consumers that
+    // only see one side.
+    const rolesToNotify = fromRole && fromRole !== escalation.role
+        ? [fromRole, escalation.role]
+        : [escalation.role];
+    for (const role of rolesToNotify) {
+        publishEscalationChange({
+            type: 'escalation.reassigned',
+            source: 'service',
+            workflowId: escalation.workflow_id || '',
+            workflowName: escalation.workflow_type || '',
+            taskQueue: escalation.task_queue || '',
+            escalationId: escalation.id,
+            role,
+            status: 'pending',
+            data: { from_role: fromRole, to_role: escalation.role },
+        });
+    }
+    return escalation;
 }
 async function getEscalation(id) {
     const client = await (0, client_1.escalations)();
@@ -402,7 +437,7 @@ async function cancelEscalationsByWorkflowId(workflowId) {
         SET status = 'cancelled', updated_at = NOW()
       WHERE workflow_id = $1
         AND status = 'pending'
-      RETURNING id, workflow_id, workflow_type, task_queue`, [workflowId]);
+      RETURNING id, workflow_id, workflow_type, task_queue, role`, [workflowId]);
     for (const row of rows) {
         publishEscalationChange({
             type: 'escalation.cancelled',
@@ -411,6 +446,7 @@ async function cancelEscalationsByWorkflowId(workflowId) {
             workflowName: row.workflow_type || '',
             taskQueue: row.task_queue || '',
             escalationId: row.id,
+            role: row.role || '',
             status: 'cancelled',
             data: { reason: 'workflow_terminated' },
         });
@@ -498,6 +534,7 @@ async function claimByMetadata(key, value, userId, durationMinutes = 30, metadat
         workflowName: escalation.workflow_type || '',
         taskQueue: escalation.task_queue || '',
         escalationId: escalation.id,
+        role: escalation.role,
         status: 'claimed',
         data: { assigned_to: userId },
     });
@@ -556,6 +593,7 @@ async function resolveByMetadataAtomic(key, value, userId, resolverPayload, meta
             workflowName: escalation.workflow_type || '',
             taskQueue: escalation.task_queue || '',
             escalationId: escalation.id,
+            role: escalation.role,
             status: 'resolved',
             data: { resolved_by: userId },
         });

package/build/services/orchestrator/condition.d.ts

@@ -21,7 +21,7 @@ export type ConditionEscalationConfig = Types.ConditionQueueConfig & {
  * written inside this workflow's Leg1 checkpoint (one commit, crash-safe — no
  * separate create activity, no enrich). `signal_key` is the signal id, so the
  * dashboard resolve endpoint (Path 0), `resolveEscalationBySignalKey`, and any
- * webhook resume the SAME job in place. `system.escalation.{id}.created` fires
+ * webhook resume the SAME job in place. `system.escalation.{role}.{id}.created` fires
  * from the engine automatically.
  *
  * ```typescript

package/build/services/orchestrator/condition.js

@@ -60,7 +60,7 @@ function toEngineConfig(escalation) {
  * written inside this workflow's Leg1 checkpoint (one commit, crash-safe — no
  * separate create activity, no enrich). `signal_key` is the signal id, so the
  * dashboard resolve endpoint (Path 0), `resolveEscalationBySignalKey`, and any
- * webhook resume the SAME job in place. `system.escalation.{id}.created` fires
+ * webhook resume the SAME job in place. `system.escalation.{role}.{id}.created` fires
  * from the engine automatically.
  *
  * ```typescript

package/build/services/persona/index.d.ts

@@ -0,0 +1,92 @@
+import type { LTPersonaRecord, LTPersonaRelationship, LTPersonaSpec, LTUserPersona, LTComposedRoleScope } from '../../types';
+import type { CreatePersonaInput, UpdatePersonaInput } from './types';
+export { PERSONA_RELATIONSHIPS, normalizeRelationship, relationshipToWriteScope, } from './types';
+export type { CreatePersonaInput, UpdatePersonaInput } from './types';
+/** Counts from one membership reconciliation pass. */
+export interface PersonaRecomputeResult {
+    granted: number;
+    refreshed: number;
+    raised: number;
+    removed: number;
+}
+/** An assignee row on the persona detail surface. */
+export interface PersonaAssignee {
+    id: string;
+    external_id: string;
+    display_name: string | null;
+    email: string | null;
+    assigned_at: Date;
+}
+export declare function listPersonas(): Promise<LTPersonaRecord[]>;
+export declare function getPersona(key: string): Promise<(LTPersonaRecord & {
+    assignees: PersonaAssignee[];
+}) | null>;
+export declare function createPersona(input: CreatePersonaInput): Promise<LTPersonaRecord>;
+export declare function updatePersona(key: string, input: UpdatePersonaInput): Promise<LTPersonaRecord | null>;
+/**
+ * Delete a persona. Holds are removed and memberships reconciled BEFORE the
+ * persona row is deleted, so rows it sustained are dropped (or re-homed to a
+ * sibling persona) rather than silently converting into direct grants.
+ */
+export declare function deletePersona(key: string): Promise<{
+    deleted: boolean;
+    recompute?: PersonaRecomputeResult;
+}>;
+/**
+ * Link a role to a persona (or update the link's relationship). The role is
+ * ensured as an FK target, and every current holder's memberships are
+ * reconciled in the same transaction.
+ */
+export declare function linkPersonaRole(key: string, role: string, relationship: LTPersonaRelationship): Promise<{
+    role: string;
+    relationship: LTPersonaRelationship;
+    recompute: PersonaRecomputeResult;
+} | null>;
+/** Unlink a role from a persona and reconcile every holder's memberships. */
+export declare function unlinkPersonaRole(key: string, role: string): Promise<{
+    unlinked: boolean;
+    personaFound: boolean;
+    recompute?: PersonaRecomputeResult;
+}>;
+/**
+ * Assign a persona to a user. Idempotent: re-assigning overlays fresh — the
+ * user's memberships are reconciled against the persona's CURRENT role links
+ * (union with every other persona they hold; direct grants only ever raised,
+ * never lowered or removed).
+ */
+export declare function assignPersona(userId: string, key: string): Promise<PersonaRecomputeResult | null>;
+/**
+ * Unassign a persona from a user. Removes only memberships the persona
+ * sustains — rows another held persona still grants are re-homed to it, and
+ * direct grants are never touched.
+ */
+export declare function unassignPersona(userId: string, key: string): Promise<{
+    unassigned: boolean;
+    personaFound: boolean;
+    recompute?: PersonaRecomputeResult;
+}>;
+/** The personas a user holds plus the composed role/scope map their memberships form. */
+export declare function getUserPersonas(userId: string): Promise<{
+    personas: LTUserPersona[];
+    roles: LTComposedRoleScope[];
+}>;
+/**
+ * Declarative, idempotent persona seeding — the static-config twin of the API
+ * surface (like roles + default_pins in the same seed pass). Each spec is
+ * authoritative for its persona: title/description overlaid, role links synced
+ * (links absent from the spec are pruned), linked roles ensured as FK targets,
+ * and every holder of a seeded persona reconciled — re-running the seed after
+ * editing a spec re-applies it to everyone holding the persona.
+ *
+ * Relationships must be canonical (normalize aliases at the API boundary).
+ */
+export declare function seedPersonas(specs: (Omit<LTPersonaSpec, 'roles'> & {
+    roles: {
+        role: string;
+        relationship: LTPersonaRelationship;
+    }[];
+})[]): Promise<{
+    personas: number;
+    links: number;
+    recompute: PersonaRecomputeResult;
+}>;

package/build/services/persona/index.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relationshipToWriteScope = exports.normalizeRelationship = exports.PERSONA_RELATIONSHIPS = void 0;
+exports.listPersonas = listPersonas;
+exports.getPersona = getPersona;
+exports.createPersona = createPersona;
+exports.updatePersona = updatePersona;
+exports.deletePersona = deletePersona;
+exports.linkPersonaRole = linkPersonaRole;
+exports.unlinkPersonaRole = unlinkPersonaRole;
+exports.assignPersona = assignPersona;
+exports.unassignPersona = unassignPersona;
+exports.getUserPersonas = getUserPersonas;
+exports.seedPersonas = seedPersonas;
+const db_1 = require("../../lib/db");
+const sql_1 = require("./sql");
+var types_1 = require("./types");
+Object.defineProperty(exports, "PERSONA_RELATIONSHIPS", { enumerable: true, get: function () { return types_1.PERSONA_RELATIONSHIPS; } });
+Object.defineProperty(exports, "normalizeRelationship", { enumerable: true, get: function () { return types_1.normalizeRelationship; } });
+Object.defineProperty(exports, "relationshipToWriteScope", { enumerable: true, get: function () { return types_1.relationshipToWriteScope; } });
+const EMPTY_RECOMPUTE = { granted: 0, refreshed: 0, raised: 0, removed: 0 };
+// ─── Internal helpers ─────────────────────────────────────────────────────────
+/** Run `work` inside a single transaction on a dedicated client. */
+async function withTransaction(work) {
+    const client = await (0, db_1.getPool)().connect();
+    try {
+        await client.query('BEGIN');
+        const result = await work((text, params) => client.query(text, params));
+        await client.query('COMMIT');
+        return result;
+    }
+    catch (err) {
+        await client.query('ROLLBACK').catch(() => { });
+        throw err;
+    }
+    finally {
+        client.release();
+    }
+}
+/** Reconcile lt_user_roles for a set of users against their held personas. */
+async function recomputeMemberships(query, userIds) {
+    if (userIds.length === 0)
+        return { ...EMPTY_RECOMPUTE };
+    const { rows } = await query(sql_1.RECOMPUTE_PERSONA_MEMBERSHIPS, [userIds]);
+    return rows[0];
+}
+async function resolvePersonaId(query, key) {
+    const { rows } = await query(sql_1.GET_PERSONA_ID_BY_KEY, [key]);
+    return rows[0]?.id ?? null;
+}
+// ─── Persona CRUD ─────────────────────────────────────────────────────────────
+async function listPersonas() {
+    const { rows } = await (0, db_1.getPool)().query(sql_1.LIST_PERSONAS);
+    return rows;
+}
+async function getPersona(key) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.GET_PERSONA_BY_KEY, [key]);
+    if (rows.length === 0)
+        return null;
+    const { rows: assignees } = await pool.query(sql_1.GET_PERSONA_ASSIGNEES, [rows[0].id]);
+    return { ...rows[0], assignees };
+}
+async function createPersona(input) {
+    const { rows } = await (0, db_1.getPool)().query(sql_1.CREATE_PERSONA, [
+        input.key,
+        input.title ?? null,
+        input.description ?? null,
+    ]);
+    return { ...rows[0], roles: [], user_count: 0 };
+}
+async function updatePersona(key, input) {
+    const { rows } = await (0, db_1.getPool)().query(sql_1.UPDATE_PERSONA, [
+        key,
+        input.title !== undefined, input.title ?? null,
+        input.description !== undefined, input.description ?? null,
+    ]);
+    if (rows.length === 0)
+        return null;
+    const detail = await getPersona(key);
+    return detail;
+}
+/**
+ * Delete a persona. Holds are removed and memberships reconciled BEFORE the
+ * persona row is deleted, so rows it sustained are dropped (or re-homed to a
+ * sibling persona) rather than silently converting into direct grants.
+ */
+async function deletePersona(key) {
+    return withTransaction(async (query) => {
+        const personaId = await resolvePersonaId(query, key);
+        if (!personaId)
+            return { deleted: false };
+        const { rows: holders } = await query(`DELETE FROM lt_user_personas WHERE persona_id = $1 RETURNING user_id`, [personaId]);
+        // Guard against drift: also reconcile any user with a row still sustained
+        // by this persona, even if no hold record remained.
+        const { rows: sustained } = await query(sql_1.LIST_SUSTAINED_USER_IDS, [personaId]);
+        const affected = [...new Set([...holders, ...sustained].map((r) => r.user_id))];
+        const recompute = await recomputeMemberships(query, affected);
+        await query(sql_1.DELETE_PERSONA, [personaId]);
+        return { deleted: true, recompute };
+    });
+}
+// ─── Role links ───────────────────────────────────────────────────────────────
+/**
+ * Link a role to a persona (or update the link's relationship). The role is
+ * ensured as an FK target, and every current holder's memberships are
+ * reconciled in the same transaction.
+ */
+async function linkPersonaRole(key, role, relationship) {
+    return withTransaction(async (query) => {
+        const personaId = await resolvePersonaId(query, key);
+        if (!personaId)
+            return null;
+        await query(sql_1.ENSURE_ROLES_EXIST, [[role]]);
+        const { rows } = await query(sql_1.UPSERT_PERSONA_ROLE, [personaId, role, relationship]);
+        const { rows: holders } = await query(sql_1.LIST_PERSONA_HOLDER_IDS, [personaId]);
+        const recompute = await recomputeMemberships(query, holders.map((r) => r.user_id));
+        return { ...rows[0], recompute };
+    });
+}
+/** Unlink a role from a persona and reconcile every holder's memberships. */
+async function unlinkPersonaRole(key, role) {
+    return withTransaction(async (query) => {
+        const personaId = await resolvePersonaId(query, key);
+        if (!personaId)
+            return { unlinked: false, personaFound: false };
+        const { rowCount } = await query(sql_1.DELETE_PERSONA_ROLE, [personaId, role]);
+        if ((rowCount ?? 0) === 0)
+            return { unlinked: false, personaFound: true };
+        const { rows: holders } = await query(sql_1.LIST_PERSONA_HOLDER_IDS, [personaId]);
+        const recompute = await recomputeMemberships(query, holders.map((r) => r.user_id));
+        return { unlinked: true, personaFound: true, recompute };
+    });
+}
+// ─── Assignment ───────────────────────────────────────────────────────────────
+/**
+ * Assign a persona to a user. Idempotent: re-assigning overlays fresh — the
+ * user's memberships are reconciled against the persona's CURRENT role links
+ * (union with every other persona they hold; direct grants only ever raised,
+ * never lowered or removed).
+ */
+async function assignPersona(userId, key) {
+    return withTransaction(async (query) => {
+        const personaId = await resolvePersonaId(query, key);
+        if (!personaId)
+            return null;
+        await query(sql_1.INSERT_USER_PERSONA, [userId, personaId]);
+        return recomputeMemberships(query, [userId]);
+    });
+}
+/**
+ * Unassign a persona from a user. Removes only memberships the persona
+ * sustains — rows another held persona still grants are re-homed to it, and
+ * direct grants are never touched.
+ */
+async function unassignPersona(userId, key) {
+    return withTransaction(async (query) => {
+        const personaId = await resolvePersonaId(query, key);
+        if (!personaId)
+            return { unassigned: false, personaFound: false };
+        const { rowCount } = await query(sql_1.DELETE_USER_PERSONA, [userId, personaId]);
+        if ((rowCount ?? 0) === 0)
+            return { unassigned: false, personaFound: true };
+        const recompute = await recomputeMemberships(query, [userId]);
+        return { unassigned: true, personaFound: true, recompute };
+    });
+}
+/** The personas a user holds plus the composed role/scope map their memberships form. */
+async function getUserPersonas(userId) {
+    const pool = (0, db_1.getPool)();
+    const [{ rows: personas }, { rows: roles }] = await Promise.all([
+        pool.query(sql_1.GET_USER_PERSONAS, [userId]),
+        pool.query(sql_1.GET_USER_COMPOSED_ROLES, [userId]),
+    ]);
+    return { personas, roles };
+}
+// ─── Declarative seed ─────────────────────────────────────────────────────────
+/**
+ * Declarative, idempotent persona seeding — the static-config twin of the API
+ * surface (like roles + default_pins in the same seed pass). Each spec is
+ * authoritative for its persona: title/description overlaid, role links synced
+ * (links absent from the spec are pruned), linked roles ensured as FK targets,
+ * and every holder of a seeded persona reconciled — re-running the seed after
+ * editing a spec re-applies it to everyone holding the persona.
+ *
+ * Relationships must be canonical (normalize aliases at the API boundary).
+ */
+async function seedPersonas(specs) {
+    if (specs.length === 0)
+        return { personas: 0, links: 0, recompute: { ...EMPTY_RECOMPUTE } };
+    return withTransaction(async (query) => {
+        const allRoles = [...new Set(specs.flatMap((s) => s.roles.map((r) => r.role)))];
+        if (allRoles.length > 0) {
+            await query(sql_1.ENSURE_ROLES_EXIST, [allRoles]);
+        }
+        const personaIds = [];
+        let links = 0;
+        for (const spec of specs) {
+            const { rows } = await query(sql_1.UPSERT_PERSONA, [
+                spec.key,
+                spec.title ?? null,
+                spec.description ?? null,
+            ]);
+            const personaId = rows[0].id;
+            personaIds.push(personaId);
+            await query(sql_1.SYNC_PERSONA_ROLES, [
+                personaId,
+                spec.roles.map((r) => r.role),
+                spec.roles.map((r) => r.relationship),
+            ]);
+            links += spec.roles.length;
+        }
+        const { rows: holders } = await query('SELECT DISTINCT user_id FROM lt_user_personas WHERE persona_id = ANY($1::uuid[])', [personaIds]);
+        const recompute = await recomputeMemberships(query, holders.map((r) => r.user_id));
+        return { personas: specs.length, links, recompute };
+    });
+}

package/build/services/persona/sql.d.ts

@@ -0,0 +1,24 @@
+export declare const LIST_PERSONAS = "SELECT p.id, p.key, p.title, p.description, r.roles, u.user_count, p.created_at, p.updated_at\n   FROM lt_personas p\n   LEFT JOIN LATERAL (\n     SELECT COALESCE(json_agg(json_build_object('role', pr.role, 'relationship', pr.relationship)\n                     ORDER BY pr.created_at, pr.role), '[]'::json) AS roles\n     FROM lt_persona_roles pr WHERE pr.persona_id = p.id\n   ) r ON true\n   LEFT JOIN LATERAL (\n     SELECT COUNT(*)::int AS user_count FROM lt_user_personas up WHERE up.persona_id = p.id\n   ) u ON true\n   ORDER BY p.key";
+export declare const GET_PERSONA_BY_KEY = "SELECT p.id, p.key, p.title, p.description, r.roles, u.user_count, p.created_at, p.updated_at\n   FROM lt_personas p\n   LEFT JOIN LATERAL (\n     SELECT COALESCE(json_agg(json_build_object('role', pr.role, 'relationship', pr.relationship)\n                     ORDER BY pr.created_at, pr.role), '[]'::json) AS roles\n     FROM lt_persona_roles pr WHERE pr.persona_id = p.id\n   ) r ON true\n   LEFT JOIN LATERAL (\n     SELECT COUNT(*)::int AS user_count FROM lt_user_personas up WHERE up.persona_id = p.id\n   ) u ON true\n   WHERE p.key = $1";
+export declare const CREATE_PERSONA = "INSERT INTO lt_personas (key, title, description) VALUES ($1, $2, $3)\n   RETURNING id, key, title, description, created_at, updated_at";
+/** Declarative upsert for the seed pass — the spec is authoritative for title/description. */
+export declare const UPSERT_PERSONA = "INSERT INTO lt_personas (key, title, description) VALUES ($1, $2, $3)\n   ON CONFLICT (key) DO UPDATE SET\n     title = EXCLUDED.title,\n     description = EXCLUDED.description,\n     updated_at = NOW()\n   RETURNING id";
+/** PATCH semantics: $2/$4 are set-sentinels gating whether $3/$5 write. */
+export declare const UPDATE_PERSONA = "UPDATE lt_personas SET\n     title       = CASE WHEN $2 THEN $3 ELSE title END,\n     description = CASE WHEN $4 THEN $5 ELSE description END,\n     updated_at  = NOW()\n   WHERE key = $1\n   RETURNING id, key, title, description, created_at, updated_at";
+export declare const DELETE_PERSONA = "DELETE FROM lt_personas WHERE id = $1";
+export declare const GET_PERSONA_ASSIGNEES = "SELECT us.id, us.external_id, us.display_name, us.email, up.created_at AS assigned_at\n   FROM lt_user_personas up\n   JOIN lt_users us ON us.id = up.user_id\n   WHERE up.persona_id = $1\n   ORDER BY up.created_at, us.external_id";
+export declare const UPSERT_PERSONA_ROLE = "INSERT INTO lt_persona_roles (persona_id, role, relationship) VALUES ($1, $2, $3)\n   ON CONFLICT (persona_id, role) DO UPDATE SET relationship = EXCLUDED.relationship\n   RETURNING role, relationship";
+export declare const DELETE_PERSONA_ROLE = "DELETE FROM lt_persona_roles WHERE persona_id = $1 AND role = $2";
+/** Replace a persona's links declaratively: prune links not in $2, upsert the rest. */
+export declare const SYNC_PERSONA_ROLES = "WITH incoming AS (\n     SELECT x.role, x.relationship\n     FROM unnest($2::text[], $3::text[]) AS x(role, relationship)\n   ), pruned AS (\n     DELETE FROM lt_persona_roles pr\n     WHERE pr.persona_id = $1 AND pr.role NOT IN (SELECT role FROM incoming)\n   )\n   INSERT INTO lt_persona_roles (persona_id, role, relationship)\n   SELECT $1, role, relationship FROM incoming\n   ON CONFLICT (persona_id, role) DO UPDATE SET relationship = EXCLUDED.relationship";
+export declare const INSERT_USER_PERSONA = "INSERT INTO lt_user_personas (user_id, persona_id) VALUES ($1, $2)\n   ON CONFLICT DO NOTHING";
+export declare const DELETE_USER_PERSONA = "DELETE FROM lt_user_personas WHERE user_id = $1 AND persona_id = $2";
+export declare const LIST_PERSONA_HOLDER_IDS = "SELECT user_id FROM lt_user_personas WHERE persona_id = $1";
+/** Users with a membership row still sustained by this persona (drift guard for delete). */
+export declare const LIST_SUSTAINED_USER_IDS = "SELECT DISTINCT user_id FROM lt_user_roles WHERE granted_by_persona = $1";
+export declare const RECOMPUTE_PERSONA_MEMBERSHIPS = "WITH affected AS (\n     SELECT unnest($1::uuid[]) AS user_id\n   ), grants AS (\n     SELECT up.user_id, pr.role,\n            MAX(CASE pr.relationship WHEN 'write-all' THEN 2 WHEN 'write-self' THEN 1 ELSE 0 END) AS write_rank,\n            (MIN(pr.persona_id::text))::uuid AS sustaining_persona\n     FROM lt_user_personas up\n     JOIN lt_persona_roles pr ON pr.persona_id = up.persona_id\n     JOIN affected a ON a.user_id = up.user_id\n     GROUP BY up.user_id, pr.role\n   ), removed AS (\n     DELETE FROM lt_user_roles ur\n     USING affected a\n     WHERE ur.user_id = a.user_id\n       AND ur.granted_by_persona IS NOT NULL\n       AND NOT EXISTS (SELECT 1 FROM grants g WHERE g.user_id = ur.user_id AND g.role = ur.role)\n     RETURNING ur.user_id, ur.role\n   ), refreshed AS (\n     UPDATE lt_user_roles ur\n     SET read_scope = 'all',\n         write_scope = CASE g.write_rank WHEN 2 THEN 'all' WHEN 1 THEN 'self' ELSE 'none' END,\n         granted_by_persona = g.sustaining_persona\n     FROM grants g\n     WHERE ur.user_id = g.user_id AND ur.role = g.role\n       AND ur.granted_by_persona IS NOT NULL\n     RETURNING ur.user_id, ur.role\n   ), raised AS (\n     UPDATE lt_user_roles ur\n     SET read_scope = 'all',\n         write_scope = CASE\n           WHEN g.write_rank = 2 THEN 'all'\n           WHEN g.write_rank = 1 AND ur.write_scope = 'none' THEN 'self'\n           ELSE ur.write_scope\n         END\n     FROM grants g\n     WHERE ur.user_id = g.user_id AND ur.role = g.role\n       AND ur.granted_by_persona IS NULL\n       AND (ur.read_scope <> 'all'\n            OR g.write_rank > CASE ur.write_scope WHEN 'all' THEN 2 WHEN 'self' THEN 1 ELSE 0 END)\n     RETURNING ur.user_id, ur.role\n   ), granted AS (\n     INSERT INTO lt_user_roles (user_id, role, type, read_scope, write_scope, granted_by_persona)\n     SELECT g.user_id, g.role, 'member', 'all',\n            CASE g.write_rank WHEN 2 THEN 'all' WHEN 1 THEN 'self' ELSE 'none' END,\n            g.sustaining_persona\n     FROM grants g\n     WHERE NOT EXISTS (SELECT 1 FROM lt_user_roles ur WHERE ur.user_id = g.user_id AND ur.role = g.role)\n     RETURNING user_id, role\n   )\n   SELECT\n     (SELECT COUNT(*)::int FROM granted)   AS granted,\n     (SELECT COUNT(*)::int FROM refreshed) AS refreshed,\n     (SELECT COUNT(*)::int FROM raised)    AS raised,\n     (SELECT COUNT(*)::int FROM removed)   AS removed";
+export declare const GET_USER_PERSONAS = "SELECT p.id, p.key, p.title, p.description, r.roles, up.created_at AS assigned_at\n   FROM lt_user_personas up\n   JOIN lt_personas p ON p.id = up.persona_id\n   LEFT JOIN LATERAL (\n     SELECT COALESCE(json_agg(json_build_object('role', pr.role, 'relationship', pr.relationship)\n                     ORDER BY pr.created_at, pr.role), '[]'::json) AS roles\n     FROM lt_persona_roles pr WHERE pr.persona_id = p.id\n   ) r ON true\n   WHERE up.user_id = $1\n   ORDER BY p.key";
+/** The composed role/scope map: every membership with its sustaining persona key (null = direct). */
+export declare const GET_USER_COMPOSED_ROLES = "SELECT ur.role, ur.read_scope, ur.write_scope, p.key AS granted_by_persona\n   FROM lt_user_roles ur\n   LEFT JOIN lt_personas p ON p.id = ur.granted_by_persona\n   WHERE ur.user_id = $1\n   ORDER BY ur.role";
+export declare const GET_PERSONA_ID_BY_KEY = "SELECT id FROM lt_personas WHERE key = $1";
+export declare const ENSURE_ROLES_EXIST = "INSERT INTO lt_roles (role) SELECT DISTINCT unnest($1::text[]) ON CONFLICT DO NOTHING";

package/build/services/persona/sql.js

@@ -0,0 +1,158 @@
+"use strict";
+// ─── Persona CRUD ─────────────────────────────────────────────────────────────
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENSURE_ROLES_EXIST = exports.GET_PERSONA_ID_BY_KEY = exports.GET_USER_COMPOSED_ROLES = exports.GET_USER_PERSONAS = exports.RECOMPUTE_PERSONA_MEMBERSHIPS = exports.LIST_SUSTAINED_USER_IDS = exports.LIST_PERSONA_HOLDER_IDS = exports.DELETE_USER_PERSONA = exports.INSERT_USER_PERSONA = exports.SYNC_PERSONA_ROLES = exports.DELETE_PERSONA_ROLE = exports.UPSERT_PERSONA_ROLE = exports.GET_PERSONA_ASSIGNEES = exports.DELETE_PERSONA = exports.UPDATE_PERSONA = exports.UPSERT_PERSONA = exports.CREATE_PERSONA = exports.GET_PERSONA_BY_KEY = exports.LIST_PERSONAS = void 0;
+/** Aggregated role links for one persona, as a JSON array column. */
+const ROLES_LATERAL = `LEFT JOIN LATERAL (
+     SELECT COALESCE(json_agg(json_build_object('role', pr.role, 'relationship', pr.relationship)
+                     ORDER BY pr.created_at, pr.role), '[]'::json) AS roles
+     FROM lt_persona_roles pr WHERE pr.persona_id = p.id
+   ) r ON true
+   LEFT JOIN LATERAL (
+     SELECT COUNT(*)::int AS user_count FROM lt_user_personas up WHERE up.persona_id = p.id
+   ) u ON true`;
+exports.LIST_PERSONAS = `SELECT p.id, p.key, p.title, p.description, r.roles, u.user_count, p.created_at, p.updated_at
+   FROM lt_personas p
+   ${ROLES_LATERAL}
+   ORDER BY p.key`;
+exports.GET_PERSONA_BY_KEY = `SELECT p.id, p.key, p.title, p.description, r.roles, u.user_count, p.created_at, p.updated_at
+   FROM lt_personas p
+   ${ROLES_LATERAL}
+   WHERE p.key = $1`;
+exports.CREATE_PERSONA = `INSERT INTO lt_personas (key, title, description) VALUES ($1, $2, $3)
+   RETURNING id, key, title, description, created_at, updated_at`;
+/** Declarative upsert for the seed pass — the spec is authoritative for title/description. */
+exports.UPSERT_PERSONA = `INSERT INTO lt_personas (key, title, description) VALUES ($1, $2, $3)
+   ON CONFLICT (key) DO UPDATE SET
+     title = EXCLUDED.title,
+     description = EXCLUDED.description,
+     updated_at = NOW()
+   RETURNING id`;
+/** PATCH semantics: $2/$4 are set-sentinels gating whether $3/$5 write. */
+exports.UPDATE_PERSONA = `UPDATE lt_personas SET
+     title       = CASE WHEN $2 THEN $3 ELSE title END,
+     description = CASE WHEN $4 THEN $5 ELSE description END,
+     updated_at  = NOW()
+   WHERE key = $1
+   RETURNING id, key, title, description, created_at, updated_at`;
+exports.DELETE_PERSONA = 'DELETE FROM lt_personas WHERE id = $1';
+exports.GET_PERSONA_ASSIGNEES = `SELECT us.id, us.external_id, us.display_name, us.email, up.created_at AS assigned_at
+   FROM lt_user_personas up
+   JOIN lt_users us ON us.id = up.user_id
+   WHERE up.persona_id = $1
+   ORDER BY up.created_at, us.external_id`;
+// ─── Role links ───────────────────────────────────────────────────────────────
+exports.UPSERT_PERSONA_ROLE = `INSERT INTO lt_persona_roles (persona_id, role, relationship) VALUES ($1, $2, $3)
+   ON CONFLICT (persona_id, role) DO UPDATE SET relationship = EXCLUDED.relationship
+   RETURNING role, relationship`;
+exports.DELETE_PERSONA_ROLE = 'DELETE FROM lt_persona_roles WHERE persona_id = $1 AND role = $2';
+/** Replace a persona's links declaratively: prune links not in $2, upsert the rest. */
+exports.SYNC_PERSONA_ROLES = `WITH incoming AS (
+     SELECT x.role, x.relationship
+     FROM unnest($2::text[], $3::text[]) AS x(role, relationship)
+   ), pruned AS (
+     DELETE FROM lt_persona_roles pr
+     WHERE pr.persona_id = $1 AND pr.role NOT IN (SELECT role FROM incoming)
+   )
+   INSERT INTO lt_persona_roles (persona_id, role, relationship)
+   SELECT $1, role, relationship FROM incoming
+   ON CONFLICT (persona_id, role) DO UPDATE SET relationship = EXCLUDED.relationship`;
+// ─── Assignment ───────────────────────────────────────────────────────────────
+exports.INSERT_USER_PERSONA = `INSERT INTO lt_user_personas (user_id, persona_id) VALUES ($1, $2)
+   ON CONFLICT DO NOTHING`;
+exports.DELETE_USER_PERSONA = 'DELETE FROM lt_user_personas WHERE user_id = $1 AND persona_id = $2';
+exports.LIST_PERSONA_HOLDER_IDS = 'SELECT user_id FROM lt_user_personas WHERE persona_id = $1';
+/** Users with a membership row still sustained by this persona (drift guard for delete). */
+exports.LIST_SUSTAINED_USER_IDS = 'SELECT DISTINCT user_id FROM lt_user_roles WHERE granted_by_persona = $1';
+// ─── Recompute: materialize persona grants into lt_user_roles ────────────────
+//
+// The single reconciliation statement behind assign, unassign, link edits,
+// persona deletion, and seeding. For every user in $1::uuid[], it derives the
+// highest-allowance union of the user's currently-held personas and reconciles
+// lt_user_roles against it:
+//
+//   removed   — persona-sustained rows no held persona still grants
+//   refreshed — persona-sustained rows overlaid fresh (union scope, re-homed
+//               provenance so unassigning one persona never drops a role a
+//               sibling persona still grants)
+//   raised    — DIRECT rows lifted to at least the union (highest allowance
+//               wins); scope is never lowered, type and provenance untouched
+//   granted   — missing rows inserted as scoped members
+//
+// Direct rows (granted_by_persona IS NULL) are never deleted here — persona
+// removal must not touch hand-tuned memberships. Write-rank encoding:
+// write-all=2 (all), write-self=1 (self), read-all=0 (none).
+exports.RECOMPUTE_PERSONA_MEMBERSHIPS = `WITH affected AS (
+     SELECT unnest($1::uuid[]) AS user_id
+   ), grants AS (
+     SELECT up.user_id, pr.role,
+            MAX(CASE pr.relationship WHEN 'write-all' THEN 2 WHEN 'write-self' THEN 1 ELSE 0 END) AS write_rank,
+            (MIN(pr.persona_id::text))::uuid AS sustaining_persona
+     FROM lt_user_personas up
+     JOIN lt_persona_roles pr ON pr.persona_id = up.persona_id
+     JOIN affected a ON a.user_id = up.user_id
+     GROUP BY up.user_id, pr.role
+   ), removed AS (
+     DELETE FROM lt_user_roles ur
+     USING affected a
+     WHERE ur.user_id = a.user_id
+       AND ur.granted_by_persona IS NOT NULL
+       AND NOT EXISTS (SELECT 1 FROM grants g WHERE g.user_id = ur.user_id AND g.role = ur.role)
+     RETURNING ur.user_id, ur.role
+   ), refreshed AS (
+     UPDATE lt_user_roles ur
+     SET read_scope = 'all',
+         write_scope = CASE g.write_rank WHEN 2 THEN 'all' WHEN 1 THEN 'self' ELSE 'none' END,
+         granted_by_persona = g.sustaining_persona
+     FROM grants g
+     WHERE ur.user_id = g.user_id AND ur.role = g.role
+       AND ur.granted_by_persona IS NOT NULL
+     RETURNING ur.user_id, ur.role
+   ), raised AS (
+     UPDATE lt_user_roles ur
+     SET read_scope = 'all',
+         write_scope = CASE
+           WHEN g.write_rank = 2 THEN 'all'
+           WHEN g.write_rank = 1 AND ur.write_scope = 'none' THEN 'self'
+           ELSE ur.write_scope
+         END
+     FROM grants g
+     WHERE ur.user_id = g.user_id AND ur.role = g.role
+       AND ur.granted_by_persona IS NULL
+       AND (ur.read_scope <> 'all'
+            OR g.write_rank > CASE ur.write_scope WHEN 'all' THEN 2 WHEN 'self' THEN 1 ELSE 0 END)
+     RETURNING ur.user_id, ur.role
+   ), granted AS (
+     INSERT INTO lt_user_roles (user_id, role, type, read_scope, write_scope, granted_by_persona)
+     SELECT g.user_id, g.role, 'member', 'all',
+            CASE g.write_rank WHEN 2 THEN 'all' WHEN 1 THEN 'self' ELSE 'none' END,
+            g.sustaining_persona
+     FROM grants g
+     WHERE NOT EXISTS (SELECT 1 FROM lt_user_roles ur WHERE ur.user_id = g.user_id AND ur.role = g.role)
+     RETURNING user_id, role
+   )
+   SELECT
+     (SELECT COUNT(*)::int FROM granted)   AS granted,
+     (SELECT COUNT(*)::int FROM refreshed) AS refreshed,
+     (SELECT COUNT(*)::int FROM raised)    AS raised,
+     (SELECT COUNT(*)::int FROM removed)   AS removed`;
+// ─── forUser ──────────────────────────────────────────────────────────────────
+exports.GET_USER_PERSONAS = `SELECT p.id, p.key, p.title, p.description, r.roles, up.created_at AS assigned_at
+   FROM lt_user_personas up
+   JOIN lt_personas p ON p.id = up.persona_id
+   LEFT JOIN LATERAL (
+     SELECT COALESCE(json_agg(json_build_object('role', pr.role, 'relationship', pr.relationship)
+                     ORDER BY pr.created_at, pr.role), '[]'::json) AS roles
+     FROM lt_persona_roles pr WHERE pr.persona_id = p.id
+   ) r ON true
+   WHERE up.user_id = $1
+   ORDER BY p.key`;
+/** The composed role/scope map: every membership with its sustaining persona key (null = direct). */
+exports.GET_USER_COMPOSED_ROLES = `SELECT ur.role, ur.read_scope, ur.write_scope, p.key AS granted_by_persona
+   FROM lt_user_roles ur
+   LEFT JOIN lt_personas p ON p.id = ur.granted_by_persona
+   WHERE ur.user_id = $1
+   ORDER BY ur.role`;
+// ─── Shared ───────────────────────────────────────────────────────────────────
+exports.GET_PERSONA_ID_BY_KEY = 'SELECT id FROM lt_personas WHERE key = $1';
+exports.ENSURE_ROLES_EXIST = `INSERT INTO lt_roles (role) SELECT DISTINCT unnest($1::text[]) ON CONFLICT DO NOTHING`;