@hotmeshio/long-tail 0.1.6 → 0.1.8

package/build/examples/types/envelopes.d.ts

@@ -24,11 +24,38 @@ export interface BasicEchoEnvelopeData {
     /** Duration to sleep before echoing (seconds). */
     sleepSeconds?: number;
 }
+/** Assembly line — durable orchestrator with sequential human task queues. */
+export interface AssemblyLineEnvelopeData {
+    /** Product name for the assembly run. */
+    productName: string;
+    /** Ordered stations the product passes through. */
+    stations: Array<{
+        stationName: string;
+        role: string;
+        instructions: string;
+    }>;
+}
+/** Step iterator — generic loop over data-driven steps with human escalations. */
+export interface StepIteratorEnvelopeData {
+    /** Display name for this run. */
+    name: string;
+    /** Dynamic list of steps — each spawns a child workflow with an escalation. */
+    steps: Array<{
+        stationName: string;
+        role: string;
+        instructions: string;
+    }>;
+}
+/** Reverter — step loop with revert support (same shape as stepIterator). */
+export type ReverterEnvelopeData = StepIteratorEnvelopeData;
 /** Map of invocable workflow type → its typed envelope data shape. */
 export type WorkflowEnvelopeMap = {
     reviewContent: ReviewContentEnvelopeData;
     kitchenSink: KitchenSinkEnvelopeData;
     basicEcho: BasicEchoEnvelopeData;
+    assemblyLine: AssemblyLineEnvelopeData;
+    stepIterator: StepIteratorEnvelopeData;
+    reverter: ReverterEnvelopeData;
 };
 /** All invocable workflow type names. */
 export type InvocableWorkflowType = keyof WorkflowEnvelopeMap;

package/build/examples/types/index.d.ts

@@ -5,6 +5,6 @@
  * Resolver types define the payload shape for resolving escalations.
  * Per-workflow types are re-exported for convenience.
  */
-export type { ReviewContentEnvelopeData, KitchenSinkEnvelopeData, BasicEchoEnvelopeData, WorkflowEnvelopeMap, InvocableWorkflowType, } from './envelopes';
+export type { ReviewContentEnvelopeData, KitchenSinkEnvelopeData, BasicEchoEnvelopeData, AssemblyLineEnvelopeData, StepIteratorEnvelopeData, ReverterEnvelopeData, WorkflowEnvelopeMap, InvocableWorkflowType, } from './envelopes';
 export type { ResolverLTBlock, BaseResolverPayload, ReviewContentResolverPayload, } from './resolvers';
 export type { ReviewContentInput, ReviewAnalysis, ReviewContentReturnData, ReviewContentReturn, ReviewContentEscalationData, ReviewContentEscalation, } from '../workflows/review-content/types';

package/build/examples/workers.js

@@ -37,6 +37,10 @@ exports.exampleWorkers = void 0;
 const reviewContentWorkflow = __importStar(require("./workflows/review-content"));
 const kitchenSinkWorkflow = __importStar(require("./workflows/kitchen-sink"));
 const basicEchoWorkflow = __importStar(require("./workflows/basic-echo"));
+const assemblyLineWorkflow = __importStar(require("./workflows/assembly-line"));
+const workstationWorkflow = __importStar(require("./workflows/assembly-line/worker"));
+const stepIteratorWorkflow = __importStar(require("./workflows/assembly-line/iterator"));
+const reverterWorkflow = __importStar(require("./workflows/assembly-line/reverter"));
 /**
  * Example workers that ship with Long Tail.
  * Pass these to `start({ workers: [...exampleWorkers] })` or enable
@@ -46,4 +50,8 @@ exports.exampleWorkers = [
     { taskQueue: 'long-tail-examples', workflow: reviewContentWorkflow.reviewContent },
     { taskQueue: 'long-tail-examples', workflow: kitchenSinkWorkflow.kitchenSink },
     { taskQueue: 'long-tail-examples', workflow: basicEchoWorkflow.basicEcho },
+    { taskQueue: 'long-tail-examples', workflow: assemblyLineWorkflow.assemblyLine },
+    { taskQueue: 'long-tail-examples', workflow: workstationWorkflow.workstation },
+    { taskQueue: 'long-tail-examples', workflow: stepIteratorWorkflow.stepIterator },
+    { taskQueue: 'long-tail-examples', workflow: reverterWorkflow.reverter },
 ];

package/build/examples/workflows/assembly-line/activities.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Assembly Line Activities
+ *
+ * Side-effect functions that run outside the deterministic workflow
+ * sandbox. Each is wrapped via proxyActivities so results are
+ * checkpointed and replayed on restart.
+ *
+ * Two responsibilities:
+ *   1. Create an escalation with signal routing so the resolve API
+ *      can wake the paused child workflow.
+ *   2. Signal the parent orchestrator when the child completes.
+ */
+export declare function createStationEscalation(input: {
+    role: string;
+    stationName: string;
+    instructions: string;
+    workflowId: string;
+    workflowType: string;
+    taskQueue: string;
+    signalId: string;
+}): Promise<string>;
+export declare function signalParent(input: {
+    parentTaskQueue: string;
+    parentWorkflowType: string;
+    parentWorkflowId: string;
+    signalId: string;
+    data: any;
+}): Promise<void>;

package/build/examples/workflows/assembly-line/activities.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * Assembly Line Activities
+ *
+ * Side-effect functions that run outside the deterministic workflow
+ * sandbox. Each is wrapped via proxyActivities so results are
+ * checkpointed and replayed on restart.
+ *
+ * Two responsibilities:
+ *   1. Create an escalation with signal routing so the resolve API
+ *      can wake the paused child workflow.
+ *   2. Signal the parent orchestrator when the child completes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStationEscalation = createStationEscalation;
+exports.signalParent = signalParent;
+const hotmesh_1 = require("@hotmeshio/hotmesh");
+const db_1 = require("../../../lib/db");
+const escalation_1 = require("../../../services/escalation");
+// ── Create station escalation ──────────────────────────────────────
+async function createStationEscalation(input) {
+    const escalation = await (0, escalation_1.createEscalation)({
+        type: 'assemblyLine',
+        subtype: input.stationName,
+        description: input.instructions,
+        priority: 2,
+        role: input.role,
+        envelope: JSON.stringify({ station: input.stationName }),
+        workflow_id: input.workflowId,
+        task_queue: input.taskQueue,
+        workflow_type: input.workflowType,
+    });
+    await (0, escalation_1.enrichEscalationRouting)(escalation.id, {
+        signal_routing: {
+            engine: 'durable',
+            taskQueue: input.taskQueue,
+            workflowType: input.workflowType,
+            workflowId: input.workflowId,
+            signalId: input.signalId,
+        },
+    }, {
+        workflowType: input.workflowType,
+        workflowId: input.workflowId,
+        taskQueue: input.taskQueue,
+    });
+    return escalation.id;
+}
+// ── Signal parent orchestrator ─────────────────────────────────────
+async function signalParent(input) {
+    const client = new hotmesh_1.Durable.Client({ connection: (0, db_1.getConnection)() });
+    const handle = await client.workflow.getHandle(input.parentTaskQueue, input.parentWorkflowType, input.parentWorkflowId);
+    await handle.signal(input.signalId, input.data);
+}

package/build/examples/workflows/assembly-line/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Assembly Line — durable orchestrator with human task queues.
+ *
+ * Demonstrates the core composition pattern without the LT interceptor:
+ *   startChild  → spawn a child workflow (fire-and-forget)
+ *   condition   → pause until the child signals back
+ *   signal      → child wakes the parent when done
+ *
+ * A product moves through sequential workstations. Each station
+ * creates an escalation for a human operator, pauses, then signals
+ * the parent when the human resolves it.
+ *
+ * No registration, no certification, no interceptor — just Durable
+ * primitives and the escalation table.
+ */
+import type { LTEnvelope } from '../../../types';
+export declare function assemblyLine(envelope: LTEnvelope): Promise<any>;

package/build/examples/workflows/assembly-line/index.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Assembly Line — durable orchestrator with human task queues.
+ *
+ * Demonstrates the core composition pattern without the LT interceptor:
+ *   startChild  → spawn a child workflow (fire-and-forget)
+ *   condition   → pause until the child signals back
+ *   signal      → child wakes the parent when done
+ *
+ * A product moves through sequential workstations. Each station
+ * creates an escalation for a human operator, pauses, then signals
+ * the parent when the human resolves it.
+ *
+ * No registration, no certification, no interceptor — just Durable
+ * primitives and the escalation table.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assemblyLine = assemblyLine;
+const hotmesh_1 = require("@hotmeshio/hotmesh");
+const defaults_1 = require("../../../modules/defaults");
+async function assemblyLine(envelope) {
+    const { productName, stations } = envelope.data;
+    const ctx = hotmesh_1.Durable.workflow.workflowInfo();
+    const results = [];
+    for (const [i, station] of stations.entries()) {
+        const signalId = `station-${i}-${ctx.workflowId}`;
+        const childWorkflowId = `workstation-${ctx.workflowId}-${i}`;
+        // Spawn child — fire-and-forget; only the start is awaited
+        await hotmesh_1.Durable.workflow.startChild({
+            workflowName: 'workstation',
+            args: [
+                {
+                    data: {
+                        ...station,
+                        parentSignalId: signalId,
+                        parentTaskQueue: 'long-tail-examples',
+                        parentWorkflowType: 'assemblyLine',
+                        parentWorkflowId: ctx.workflowId,
+                    },
+                    metadata: { source: 'assembly-line', station: station.stationName },
+                },
+            ],
+            taskQueue: 'long-tail-examples',
+            workflowId: childWorkflowId,
+            expire: defaults_1.JOB_EXPIRE_SECS,
+            entity: 'workstation',
+        });
+        // Pause until the child signals back with its result
+        const result = await hotmesh_1.Durable.workflow.condition(signalId);
+        results.push(result);
+    }
+    return {
+        type: 'return',
+        data: {
+            productName,
+            stations: results,
+            completedAt: new Date().toISOString(),
+        },
+    };
+}

package/build/examples/workflows/assembly-line/iterator.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Step Iterator — generic durable loop over dynamic steps.
+ *
+ * Proves that the number and shape of steps can be entirely
+ * data-driven. The orchestrator knows nothing about grinder,
+ * gluer, or any specific station — it just walks the list,
+ * spawns a child for each, and waits for the signal.
+ *
+ * Reuses the same `workstation` child workflow as the assembly line.
+ */
+import type { LTEnvelope } from '../../../types';
+export declare function stepIterator(envelope: LTEnvelope): Promise<any>;

package/build/examples/workflows/assembly-line/iterator.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * Step Iterator — generic durable loop over dynamic steps.
+ *
+ * Proves that the number and shape of steps can be entirely
+ * data-driven. The orchestrator knows nothing about grinder,
+ * gluer, or any specific station — it just walks the list,
+ * spawns a child for each, and waits for the signal.
+ *
+ * Reuses the same `workstation` child workflow as the assembly line.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stepIterator = stepIterator;
+const hotmesh_1 = require("@hotmeshio/hotmesh");
+const defaults_1 = require("../../../modules/defaults");
+async function stepIterator(envelope) {
+    const { name, steps } = envelope.data;
+    const ctx = hotmesh_1.Durable.workflow.workflowInfo();
+    const results = [];
+    for (const [i, step] of steps.entries()) {
+        const signalId = `step-${i}-${ctx.workflowId}`;
+        const childWorkflowId = `workstation-${ctx.workflowId}-${i}`;
+        await hotmesh_1.Durable.workflow.startChild({
+            workflowName: 'workstation',
+            args: [
+                {
+                    data: {
+                        ...step,
+                        parentSignalId: signalId,
+                        parentTaskQueue: 'long-tail-examples',
+                        parentWorkflowType: 'stepIterator',
+                        parentWorkflowId: ctx.workflowId,
+                    },
+                    metadata: { source: 'step-iterator', step: i },
+                },
+            ],
+            taskQueue: 'long-tail-examples',
+            workflowId: childWorkflowId,
+            expire: defaults_1.JOB_EXPIRE_SECS,
+            entity: 'workstation',
+        });
+        const result = await hotmesh_1.Durable.workflow.condition(signalId);
+        results.push(result);
+    }
+    return {
+        type: 'return',
+        data: {
+            name,
+            totalSteps: steps.length,
+            steps: results,
+            completedAt: new Date().toISOString(),
+        },
+    };
+}

package/build/examples/workflows/assembly-line/reverter.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Reverter — durable step loop with revert support.
+ *
+ * Like stepIterator, but each human resolution can send the
+ * pipeline backwards. The resolver payload controls flow:
+ *
+ *   { approved: true }              → advance to next step
+ *   { approved: false, revertSteps: 1 }  → go back 1 step
+ *   { approved: false, revertSteps: 2 }  → go back 2 steps
+ *
+ * The orchestrator tracks a monotonic attempt counter so every
+ * child spawn gets a unique workflow ID and signal key — even
+ * when revisiting a step after a revert.
+ *
+ * The full history (approvals + reverts) is recorded in the result.
+ */
+import type { LTEnvelope } from '../../../types';
+export declare function reverter(envelope: LTEnvelope): Promise<any>;

package/build/examples/workflows/assembly-line/reverter.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * Reverter — durable step loop with revert support.
+ *
+ * Like stepIterator, but each human resolution can send the
+ * pipeline backwards. The resolver payload controls flow:
+ *
+ *   { approved: true }              → advance to next step
+ *   { approved: false, revertSteps: 1 }  → go back 1 step
+ *   { approved: false, revertSteps: 2 }  → go back 2 steps
+ *
+ * The orchestrator tracks a monotonic attempt counter so every
+ * child spawn gets a unique workflow ID and signal key — even
+ * when revisiting a step after a revert.
+ *
+ * The full history (approvals + reverts) is recorded in the result.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reverter = reverter;
+const hotmesh_1 = require("@hotmeshio/hotmesh");
+const defaults_1 = require("../../../modules/defaults");
+async function reverter(envelope) {
+    const { name, steps } = envelope.data;
+    const ctx = hotmesh_1.Durable.workflow.workflowInfo();
+    const history = [];
+    const finalResults = [];
+    let stepIndex = 0;
+    let attempt = 0;
+    while (stepIndex < steps.length) {
+        const step = steps[stepIndex];
+        const signalId = `step-${stepIndex}-a${attempt}-${ctx.workflowId}`;
+        const childWorkflowId = `workstation-${ctx.workflowId}-${stepIndex}-a${attempt}`;
+        await hotmesh_1.Durable.workflow.startChild({
+            workflowName: 'workstation',
+            args: [
+                {
+                    data: {
+                        ...step,
+                        parentSignalId: signalId,
+                        parentTaskQueue: 'long-tail-examples',
+                        parentWorkflowType: 'reverter',
+                        parentWorkflowId: ctx.workflowId,
+                    },
+                    metadata: {
+                        source: 'reverter',
+                        step: stepIndex,
+                        attempt,
+                        totalSteps: steps.length,
+                    },
+                },
+            ],
+            taskQueue: 'long-tail-examples',
+            workflowId: childWorkflowId,
+            expire: defaults_1.JOB_EXPIRE_SECS,
+            entity: 'workstation',
+        });
+        const result = await hotmesh_1.Durable.workflow.condition(signalId);
+        const approved = result.resolution?.approved !== false;
+        const revertSteps = Number(result.resolution?.revertSteps) || 0;
+        history.push({
+            type: approved ? 'advance' : 'revert',
+            stepIndex,
+            stationName: step.stationName,
+            attempt,
+            resolution: result.resolution,
+            completedAt: result.completedAt,
+        });
+        attempt++;
+        if (approved) {
+            finalResults[stepIndex] = result;
+            stepIndex++;
+        }
+        else {
+            // Clamp revert target to 0
+            stepIndex = Math.max(0, stepIndex - revertSteps);
+        }
+    }
+    return {
+        type: 'return',
+        data: {
+            name,
+            totalSteps: steps.length,
+            totalAttempts: attempt,
+            steps: finalResults,
+            history,
+            completedAt: new Date().toISOString(),
+        },
+    };
+}

package/build/examples/workflows/assembly-line/types.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Assembly Line types.
+ *
+ * Defines the station config passed in the envelope and the
+ * result shape each station returns when a human resolves it.
+ */
+export interface AssemblyLineStation {
+    stationName: string;
+    role: string;
+    instructions: string;
+}
+export interface StationEnvelopeData {
+    stationName: string;
+    role: string;
+    instructions: string;
+    parentSignalId: string;
+    parentTaskQueue: string;
+    parentWorkflowType: string;
+    parentWorkflowId: string;
+}
+export interface StationResult {
+    stationName: string;
+    resolution: Record<string, any>;
+    completedAt: string;
+}

package/build/examples/workflows/assembly-line/types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Assembly Line types.
+ *
+ * Defines the station config passed in the envelope and the
+ * result shape each station returns when a human resolves it.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/examples/workflows/assembly-line/worker.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Workstation — child workflow for the assembly line.
+ *
+ * Each workstation:
+ *   1. Creates an escalation assigned to its role (grinder, gluer, etc.)
+ *   2. Pauses (condition) until a human claims and resolves the escalation
+ *   3. Signals the parent orchestrator with the result
+ *
+ * No interceptor, no registration — just raw Durable primitives
+ * and a direct escalation record with signal routing metadata.
+ */
+import type { LTEnvelope } from '../../../types';
+export declare function workstation(envelope: LTEnvelope): Promise<any>;

package/build/examples/workflows/assembly-line/worker.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * Workstation — child workflow for the assembly line.
+ *
+ * Each workstation:
+ *   1. Creates an escalation assigned to its role (grinder, gluer, etc.)
+ *   2. Pauses (condition) until a human claims and resolves the escalation
+ *   3. Signals the parent orchestrator with the result
+ *
+ * No interceptor, no registration — just raw Durable primitives
+ * and a direct escalation record with signal routing metadata.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workstation = workstation;
+const hotmesh_1 = require("@hotmeshio/hotmesh");
+const activities = __importStar(require("./activities"));
+const { createStationEscalation, signalParent } = hotmesh_1.Durable.workflow.proxyActivities({ activities });
+async function workstation(envelope) {
+    const { stationName, role, instructions, parentSignalId, parentTaskQueue, parentWorkflowType, parentWorkflowId, } = envelope.data;
+    const ctx = hotmesh_1.Durable.workflow.workflowInfo();
+    const localSignalId = `station-done-${ctx.workflowId}`;
+    // 1. Create escalation — human sees this in their queue
+    await createStationEscalation({
+        role,
+        stationName,
+        instructions,
+        workflowId: ctx.workflowId,
+        workflowType: 'workstation',
+        taskQueue: 'long-tail-examples',
+        signalId: localSignalId,
+    });
+    // 2. Pause until the human resolves the escalation
+    const resolution = await hotmesh_1.Durable.workflow.condition(localSignalId);
+    // 3. Build result and signal the parent orchestrator
+    const result = {
+        stationName,
+        resolution,
+        completedAt: new Date().toISOString(),
+    };
+    await signalParent({
+        parentTaskQueue,
+        parentWorkflowType,
+        parentWorkflowId,
+        signalId: parentSignalId,
+        data: result,
+    });
+    return { type: 'return', data: result };
+}

package/build/index.d.ts

@@ -37,3 +37,7 @@ export { getToolContext } from './services/iam/context';
 export { registerMcpTool } from './services/mcp/register-tool';
 export { getSystemWorkers, builtinMcpServerFactories } from './system';
 export { seedSystemMcpServers } from './system/seed';
+export { CallbackEventAdapter } from './lib/events/callback';
+export { createClient } from './sdk';
+export type { LTClient, LTClientOptions } from './sdk';
+export * as api from './api';

package/build/index.js

@@ -36,7 +36,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.seedSystemMcpServers = exports.builtinMcpServerFactories = exports.getSystemWorkers = exports.registerMcpTool = exports.getToolContext = exports.getActivityIdentity = exports.seedExamples = exports.exampleWorkers = exports.McpEscalationStrategy = exports.DefaultEscalationStrategy = exports.escalationStrategyRegistry = exports.McpVisionServer = exports.McpTranslationServer = exports.McpServer = exports.McpClient = exports.McpService = exports.BuiltInMcpAdapter = exports.mcpRegistry = exports.defaultMaintenanceConfig = exports.maintenanceRegistry = exports.PinoLoggerAdapter = exports.loggerRegistry = exports.HoneycombTelemetryAdapter = exports.telemetryRegistry = exports.publishWorkflowEvent = exports.publishEscalationEvent = exports.publishTaskEvent = exports.publishMilestoneEvent = exports.SocketIOEventAdapter = exports.InMemoryEventAdapter = exports.NatsEventAdapter = exports.eventRegistry = exports.ltConfig = exports.UserService = exports.ConfigService = exports.EscalationService = exports.TaskService = exports.signToken = exports.requireAdmin = exports.requireAuth = exports.createAuthMiddleware = exports.JwtAuthAdapter = exports.executeLT = exports.createLTActivityInterceptor = exports.createLTInterceptor = exports.registerLT = exports.start = void 0;
+exports.api = exports.createClient = exports.CallbackEventAdapter = exports.seedSystemMcpServers = exports.builtinMcpServerFactories = exports.getSystemWorkers = exports.registerMcpTool = exports.getToolContext = exports.getActivityIdentity = exports.seedExamples = exports.exampleWorkers = exports.McpEscalationStrategy = exports.DefaultEscalationStrategy = exports.escalationStrategyRegistry = exports.McpVisionServer = exports.McpTranslationServer = exports.McpServer = exports.McpClient = exports.McpService = exports.BuiltInMcpAdapter = exports.mcpRegistry = exports.defaultMaintenanceConfig = exports.maintenanceRegistry = exports.PinoLoggerAdapter = exports.loggerRegistry = exports.HoneycombTelemetryAdapter = exports.telemetryRegistry = exports.publishWorkflowEvent = exports.publishEscalationEvent = exports.publishTaskEvent = exports.publishMilestoneEvent = exports.SocketIOEventAdapter = exports.InMemoryEventAdapter = exports.NatsEventAdapter = exports.eventRegistry = exports.ltConfig = exports.UserService = exports.ConfigService = exports.EscalationService = exports.TaskService = exports.signToken = exports.requireAdmin = exports.requireAuth = exports.createAuthMiddleware = exports.JwtAuthAdapter = exports.executeLT = exports.createLTActivityInterceptor = exports.createLTInterceptor = exports.registerLT = exports.start = void 0;
 const config_1 = require("./modules/config");
 const logger_1 = require("./lib/logger");
 const start_1 = require("./start");
@@ -117,6 +117,11 @@ Object.defineProperty(exports, "getSystemWorkers", { enumerable: true, get: func
 Object.defineProperty(exports, "builtinMcpServerFactories", { enumerable: true, get: function () { return system_1.builtinMcpServerFactories; } });
 var seed_1 = require("./system/seed");
 Object.defineProperty(exports, "seedSystemMcpServers", { enumerable: true, get: function () { return seed_1.seedSystemMcpServers; } });
+var callback_1 = require("./lib/events/callback");
+Object.defineProperty(exports, "CallbackEventAdapter", { enumerable: true, get: function () { return callback_1.CallbackEventAdapter; } });
+var sdk_1 = require("./sdk");
+Object.defineProperty(exports, "createClient", { enumerable: true, get: function () { return sdk_1.createClient; } });
+exports.api = __importStar(require("./api"));
 // ─── Server ──────────────────────────────────────────────────────────────────
 async function main() {
     const honeycombKey = process.env.HONEYCOMB_API_KEY;

package/build/lib/db/schemas/004_workflow_sets.sql

@@ -0,0 +1,29 @@
+-- Workflow sets: groups of related workflows produced by plan mode.
+
+CREATE TABLE IF NOT EXISTS lt_workflow_sets (
+  id                 UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  name               TEXT UNIQUE NOT NULL,
+  description        TEXT,
+  specification      TEXT NOT NULL,
+  plan               JSONB NOT NULL DEFAULT '[]'::JSONB,
+  namespaces         TEXT[] NOT NULL DEFAULT '{}',
+  status             TEXT NOT NULL DEFAULT 'planning'
+                       CHECK (status IN ('planning','planned','building','deploying','completed','failed')),
+  source_workflow_id TEXT,
+  created_at         TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  updated_at         TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE OR REPLACE TRIGGER trg_lt_workflow_sets_updated_at
+  BEFORE UPDATE ON lt_workflow_sets
+  FOR EACH ROW EXECUTE FUNCTION lt_set_updated_at();
+
+-- Extend lt_yaml_workflows with set membership columns
+ALTER TABLE lt_yaml_workflows ADD COLUMN IF NOT EXISTS set_id UUID
+  REFERENCES lt_workflow_sets(id) ON DELETE SET NULL;
+ALTER TABLE lt_yaml_workflows ADD COLUMN IF NOT EXISTS set_role TEXT
+  CHECK (set_role IN ('leaf', 'composition', 'router'));
+ALTER TABLE lt_yaml_workflows ADD COLUMN IF NOT EXISTS set_build_order INTEGER;
+
+CREATE INDEX IF NOT EXISTS idx_lt_yaml_workflows_set_id
+  ON lt_yaml_workflows (set_id) WHERE set_id IS NOT NULL;

package/build/lib/db/schemas/005_unique_graph_topic.sql

@@ -0,0 +1,7 @@
+-- Enforce unique graph_topic per app_id for non-archived workflows.
+-- Two active/deployed/draft workflows in the same namespace must not
+-- share a subscribes topic — deploying them would cause routing collisions.
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_lt_yaml_workflows_app_topic_unique
+  ON lt_yaml_workflows (app_id, graph_topic)
+  WHERE status != 'archived';

package/build/lib/db/schemas/011_system_workflow_configs.sql

@@ -13,6 +13,9 @@ VALUES
    '{}'),
   ('mcpWorkflowBuilder', 'long-tail-system', 'engineer', false,
    'Direct pipeline builder — LLM constructs DAG from tool schemas',
+   '{}'),
+  ('mcpWorkflowPlanner', 'long-tail-system', 'engineer', false,
+   'Plan mode — decomposes specifications into multi-workflow sets',
    '{}')
 ON CONFLICT (workflow_type) DO NOTHING;
 
@@ -28,3 +31,7 @@ ON CONFLICT (workflow_type, role) DO NOTHING;
 INSERT INTO lt_config_roles (workflow_type, role)
 SELECT 'mcpWorkflowBuilder', unnest(ARRAY['reviewer', 'engineer', 'admin'])
 ON CONFLICT (workflow_type, role) DO NOTHING;
+
+INSERT INTO lt_config_roles (workflow_type, role)
+SELECT 'mcpWorkflowPlanner', unnest(ARRAY['reviewer', 'engineer', 'admin'])
+ON CONFLICT (workflow_type, role) DO NOTHING;