@hotmeshio/long-tail 0.4.12 → 0.4.13

package/README.md

@@ -1,41 +1,14 @@
 # Long Tail
 
-Long Tail turns your PostgreSQL database into a workflow engine where human and AI work share the same durable execution path. Hand off, pull back, escalate, automate — without rewriting systems or losing continuity.
+Write durable workflows in TypeScript. When they need a human, they escalate. When they need AI, they orchestrate. When a pattern repeats, they compile it away. Postgres is the engine.
 
 ```bash
 npm install @hotmeshio/long-tail
 ```
 
-## Use Long Tail for
+## How it works
 
-- **Durable execution** — Your functions run as workflows and checkpoint to Postgres. If the process crashes, execution resumes from the last completed step.
-- **Identity everywhere** — Workflows know who started them, whose credentials govern their execution, and what permissions are in play. IAM is not bolted on — it's woven into every activity call.
-- **Human-in-the-loop** — When confidence is low, the workflow escalates. RBAC-scoped escalation chains route work to the right reviewer. Approval workflows, content review, document verification — the pattern is the same.
-- **AI triage** — When human-in-the-loop teams can't resolve a request, AI takes over. Its tool calls are checkpointed. And when the fix works, it compiles into a deterministic pipeline for next time.
-- **MCP tool orchestration** — Describe what you need. If you've registered the tools, the Pipeline Designer builds the workflow. Every compiled pipeline deploys as a reusable MCP tool.
-
-A dashboard, REST API, and live event stream ship with the package. Use what you need.
-
-## Start
-
-Point at Postgres. Everything else is optional.
-
-```typescript
-import { start } from '@hotmeshio/long-tail';
-import * as myWorkflow from './workflows/my-workflow';
-
-const lt = await start({
-  database: { host: 'localhost', port: 5432, user: 'postgres', password: 'password', database: 'mydb' },
-  workers: [{ taskQueue: 'default', workflow: myWorkflow.reviewContent }],
-  auth: { secret: process.env.JWT_SECRET },
-});
-```
-
-Dashboard at [http://localhost:3000](http://localhost:3000). The [boilerplate](https://github.com/hotmeshio/long-tail-boilerplate) has a working project with custom MCP servers, MinIO, and example workflows.
-
-## Write a Durable Workflow
-
-A workflow receives an envelope and returns a result. Each activity call checkpoints — no work is lost, no step runs twice.
+You write a workflow function. Each activity call checkpoints to Postgres — if the process crashes, it resumes from the last completed step.
 
 ```typescript
 import { Durable } from '@hotmeshio/hotmesh';
@@ -51,6 +24,7 @@ export async function reviewContent(envelope: LTEnvelope) {
     return { type: 'return' as const, data: { approved: true, analysis } };
   }
 
+  // Low confidence — escalate to a human reviewer
   return {
     type: 'escalation' as const,
     role: 'reviewer',
@@ -60,32 +34,39 @@ export async function reviewContent(envelope: LTEnvelope) {
 }
 ```
 
-Activities are plain functions with side effects — API calls, LLM invocations, database queries. The `proxyActivities` call wraps them so the engine can checkpoint each result.
+That's a complete workflow. It runs, checkpoints, and when confidence is low, it hands off to a human. The human resolves it through the dashboard or API, and the workflow completes. No separate queue system, no webhook callbacks — the escalation is part of the execution.
+
+Activities are plain functions:
 
 ```typescript
-// activities.ts
 export async function analyzeContent(content: string) {
   const result = await llm.classify(content);
   return { confidence: result.confidence, flags: result.flags };
 }
 ```
 
-## Compile Workflows
+## Start
 
-Write durable workflows in TypeScript. Compile to YAML DAGs that run without replay overhead. `ltc` is the compiler — like `tsc` for workflows.
+Point at Postgres. Everything else is optional.
 
-```bash
-export ANTHROPIC_API_KEY=sk-ant-...
+```typescript
+import { start } from '@hotmeshio/long-tail';
 
-npx ltc compile workflows/              # scan and compile all workflow files
-npx ltc compile --dry-run               # discover without compiling
+const lt = await start({
+  database: { host: 'localhost', port: 5432, user: 'postgres', password: 'password', database: 'mydb' },
+  workers: [{ taskQueue: 'default', workflow: reviewContent }],
+});
 ```
 
-The source is the spec. The compiled YAML is the optimized execution. Both live in the repo. See the [Compiler Guide](docs/compiler.md).
+Dashboard at [http://localhost:3000](http://localhost:3000). The [boilerplate](https://github.com/hotmeshio/long-tail-boilerplate) has a working project with workflows, MCP servers, and MinIO.
+
+## The pattern
 
-## Certify a Workflow
+Most systems start with a durable workflow and stop there. Long Tail keeps going.
 
-Any durable workflow can be promoted to **certified** through the dashboard or API. A certified workflow gains interceptor guarantees: failures escalate instead of throwing, escalation chains route through roles, and every error is either handled or surfaced. It cannot silently fail.
+**Step 1 — Author a durable workflow.** Your function checkpoints to Postgres. It can sleep, branch, call child workflows, wait for signals. Standard durable execution.
+
+**Step 2 — Certify it.** Promotion to certified adds interceptor guarantees: failures escalate instead of throwing, escalation chains route through RBAC-scoped roles, and every error is either handled or surfaced. It cannot silently fail.
 
 ```bash
 curl -X PUT http://localhost:3000/api/workflows/reviewContent/config \
@@ -93,13 +74,17 @@ curl -X PUT http://localhost:3000/api/workflows/reviewContent/config \
   -d '{ "invocable": true, "task_queue": "default", "default_role": "reviewer" }'
 ```
 
-De-certifying removes the interceptor. The workflow continues as a standard durable workflow — same code, different guarantees.
+**Step 3 — React to events.** Workflows publish topics. Agents subscribe. When `activity.failed` fires, an automation can re-run the step, notify a team, or trigger a different workflow. The choreography is dynamic — add subscribers through the dashboard without changing code.
+
+**Step 4 — Compile what repeats.** The Pipeline Designer takes a working execution and compiles it into a deterministic YAML DAG. No LLM at runtime, no replay overhead, typed inputs and outputs. It deploys as a reusable tool that any workflow or API call can invoke.
+
+Over time, the system accumulates compiled tools. Problems that once required a human, then required AI reasoning, eventually require neither.
 
-## Register MCP Servers
+## Register MCP tools
 
-Long Tail connects to any MCP server — an npm package, a remote service, or one you write yourself. Registered tools become durable activities and are available to the Pipeline Designer.
+Long Tail connects to any MCP server. Registered tools become durable activities and are available to the Pipeline Designer.
 
-**Use an existing package** — no code, just register:
+**Existing package — no code:**
 
 ```bash
 curl -X POST http://localhost:3000/api/mcp/servers \
@@ -113,21 +98,14 @@ curl -X POST http://localhost:3000/api/mcp/servers \
   }'
 ```
 
-**Connect a remote server** — point at a URL:
+**Remote server — point at a URL:**
 
 ```bash
 curl -X POST http://localhost:3000/api/mcp/servers \
-  -H 'Content-Type: application/json' \
-  -d '{
-    "name": "my-python-server",
-    "transport_type": "sse",
-    "transport_config": { "url": "http://python-service:8000/mcp" },
-    "tags": ["ml", "classification"],
-    "compile_hints": "Returns confidence scores. Use threshold 0.85 for auto-approve."
-  }'
+  -d '{ "name": "my-python-server", "transport_type": "sse", "transport_config": { "url": "http://python-service:8000/mcp" } }'
 ```
 
-**Write your own** and register it in-process:
+**In-process — write your own:**
 
 ```typescript
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
@@ -139,8 +117,8 @@ export function createImageToolsServer(): McpServer {
 
   registerMcpTool(server, 'resize_image', 'Resize an image.', {
     path: z.string().describe('Path to the image'),
-    width: z.number().optional().describe('Target width'),
-    height: z.number().optional().describe('Target height'),
+    width: z.number().optional(),
+    height: z.number().optional(),
   }, async (args: any) => ({
     content: [{ type: 'text', text: JSON.stringify(await resize(args)) }],
   }));
@@ -152,36 +130,33 @@ export function createImageToolsServer(): McpServer {
 ```typescript
 const lt = await start({
   // ...
-  mcp: {
-    serverFactories: { 'image-tools': createImageToolsServer },
-  },
+  mcp: { serverFactories: { 'image-tools': createImageToolsServer } },
 });
 ```
 
-All three paths produce the same outcome: tools callable as durable activities. Tags enable discovery. Compile hints guide the compiler when tools are compiled into deterministic pipelines. See the [MCP guide](docs/mcp.md) for the full registration lifecycle.
+All three paths produce the same outcome: tools callable as durable activities. See the [MCP guide](docs/mcp.md).
 
-## Ask It Anything
+## Compile workflows
 
-Once your tools are registered, the Pipeline Designer orchestrates them. Describe what you need in plain language:
+The `ltc` compiler scans TypeScript workflow files and compiles them to YAML DAGs — like `tsc` for workflows.
 
-> *"Log into localhost:3000 as superadmin, navigate to every page in the sidebar, and save a screenshot of each."*
-
-The system discovers the right MCP servers, calls the tools, chains the results. If it works, the compilation wizard converts the execution into a deterministic pipeline — parameterized inputs, typed schema, no LLM at runtime. It deploys as a new MCP tool that any workflow, agent, or API call can invoke.
+```bash
+export ANTHROPIC_API_KEY=sk-ant-...
+npx ltc compile workflows/
+```
 
-The inventory of compiled tools grows over time. The need for LLM reasoning shrinks. Problems that once required a human, then required an AI, eventually require neither.
+The source is the spec. The compiled YAML is the optimized execution. Both live in the repo. See the [Compiler Guide](docs/compiler.md).
 
-## Full Configuration
+## Full configuration
 
 ```typescript
 const lt = await start({
   database: { connectionString: process.env.DATABASE_URL },
-  workers: [{ taskQueue: 'default', workflow: myWorkflow.reviewContent }],
+  workers: [{ taskQueue: 'default', workflow: reviewContent }],
 
   // Everything below is optional
-  mcp: {
-    server: { enabled: true },
-    serverFactories: { 'my-tools': createMyToolsServer },
-  },
+  seed: { admin: { externalId: 'admin', password: process.env.ADMIN_PASSWORD } },
+  mcp: { server: { enabled: true }, serverFactories: { 'my-tools': createMyToolsServer } },
   escalation: { strategy: 'mcp' },
   auth: { secret: process.env.JWT_SECRET },
   telemetry: { honeycomb: { apiKey: process.env.HNY } },
@@ -190,56 +165,57 @@ const lt = await start({
 });
 ```
 
-## Use as a Package (No HTTP Server)
+## Embed in an existing app
 
-Long Tail can run as an embedded package inside your existing application — no Express server, no socket.io, no extra ports. The same API surface is available as direct function calls.
+Long Tail runs as an embedded package inside NestJS, Express, or any Node.js application. No extra HTTP server, no extra ports.
 
 ```typescript
 import { start, createClient } from '@hotmeshio/long-tail';
 
-await start({
+const lt = await start({
   database: { connectionString: process.env.DATABASE_URL },
   server: { enabled: false },
-  workers: [{ taskQueue: 'default', workflow: reviewContent.reviewContent }],
+  seed: { admin: { externalId: 'system' } },
+  workers: [{ taskQueue: 'default', workflow: reviewContent }],
 });
 
-const lt = createClient({ auth: { userId: 'system' } });
+const client = createClient({ auth: { userId: lt.adminUserId } });
 
-// Same operations as the REST API — no HTTP overhead
-const tasks = await lt.tasks.list({ status: 'completed', limit: 10 });
-const result = await lt.escalations.claim({ id: 'esc_123', durationMinutes: 30 });
+const tasks = await client.tasks.list({ status: 'completed', limit: 10 });
+const result = await client.escalations.claim({ id: 'esc_123', durationMinutes: 30 });
 ```
 
-Subscribe to events with callbacks instead of socket.io:
+Mount the dashboard at a subpath:
 
 ```typescript
-lt.events.on('task.completed', (event) => {
-  console.log('done:', event.workflowId);
-});
+import { LTExpressAdapter } from '@hotmeshio/long-tail';
 
-lt.events.on('escalation.*', (event) => {
-  notifyTeam(event);
-});
+const adapter = new LTExpressAdapter();
+adapter.setBasePath('/admin/longtail');
+app.use('/admin/longtail', adapter.getRouter());
+```
+
+Subscribe to events with callbacks:
+
+```typescript
+client.events.on('task.completed', (event) => console.log('done:', event.workflowId));
+client.events.on('escalation.*', (event) => notifyTeam(event));
 ```
 
-Every SDK call returns an `LTApiResult` — same status codes, same validation, same RBAC. The transport is the only thing that changes. See the [SDK guide](docs/sdk.md) for the full API reference.
+Every SDK call returns an `LTApiResult` — same status codes, same validation, same RBAC. See the [SDK guide](docs/sdk.md).
 
 ## Deployment
 
 Three modes from the same codebase:
 
 ```typescript
-// 1. Standalone — dashboard + REST API + workers
+// Standalone — dashboard + API + workers
 await start({ database: { connectionString: process.env.DATABASE_URL } });
 
-// 2. Worker-only — workflow execution, no HTTP server
-await start({
-  database: { connectionString: process.env.DATABASE_URL },
-  server: { enabled: false },
-  workers: [{ taskQueue: 'default', workflow: reviewContent.reviewContent }],
-});
+// Worker-only — no HTTP server
+await start({ database: { connectionString: process.env.DATABASE_URL }, server: { enabled: false }, workers: [...] });
 
-// 3. Embedded — inside your NestJS/Next.js/Express app, SDK calls only
+// Embedded — inside your app, SDK calls only
 await start({ database: { connectionString: process.env.DATABASE_URL }, server: { enabled: false } });
 const lt = createClient({ auth: { userId: 'service' } });
 ```
@@ -250,12 +226,12 @@ All modes share PostgreSQL and scale independently. See [Cloud Deployment](docs/
 
 | Guide | What it covers |
 |-------|---------------|
-| [The Long Tail Story](docs/story.md) | Why this exists, what accumulates over time, what you own |
+| [The Long Tail Story](docs/story.md) | Why this exists, what accumulates over time |
 | [Workflows](docs/workflows.md) | Activities, interceptor, escalation lifecycle, composition |
 | [IAM](docs/iam.md) | Identity propagation, service accounts, credential exchange |
 | [Dashboard](docs/dashboard.md) | Navigation, key pages, event feed |
 | [MCP](docs/mcp.md) | Server registration, tool calls, human queue |
-| [Compilation](docs/compilation.md) | Dynamic → deterministic pipeline wizard |
+| [Compilation](docs/compilation.md) | Dynamic to deterministic pipeline wizard |
 | [Compiler](docs/compiler.md) | `ltc compile` — durable TypeScript to YAML DAGs |
 | [CLI](docs/cli.md) | `ltc` — terminal access to workflows, escalations, knowledge, MCP |
 | [Escalation Strategies](docs/escalation-strategies.md) | Default, MCP triage, custom handlers |
@@ -266,7 +242,7 @@ All modes share PostgreSQL and scale independently. See [Cloud Deployment](docs/
 
 **Adapters:** [Auth](docs/auth.md) · [Events](docs/events.md) · [Telemetry](docs/telemetry.md) · [Logging](docs/logging.md) · [Maintenance](docs/maintenance.md) · [OAuth](docs/oauth-and-delegation.md)
 
-**HTTP API:** [Workflows](docs/api/http/workflows.md) · [Tasks](docs/api/http/tasks.md) · [Escalations](docs/api/http/escalations.md) · [YAML Workflows](docs/api/http/yaml-workflows.md) · [Users](docs/api/http/users.md) · [Roles](docs/api/http/roles.md) · [Service Accounts](docs/api/http/service-accounts.md) · [MCP Servers](docs/api/http/mcp-servers.md) · [MCP Runs](docs/api/http/mcp-runs.md) · [Exports](docs/api/http/exports.md)
+**HTTP API:** [Workflows](docs/api/http/workflows.md) · [Tasks](docs/api/http/tasks.md) · [Escalations](docs/api/http/escalations.md) · [YAML Workflows](docs/api/http/yaml-workflows.md) · [Users](docs/api/http/users.md) · [Roles](docs/api/http/roles.md) · [Service Accounts](docs/api/http/service-accounts.md) · [MCP Servers](docs/api/http/mcp-servers.md) · [Pipelines](docs/api/http/pipelines.md) · [Exports](docs/api/http/exports.md)
 
 **SDK:** [Overview](docs/sdk.md) · [Workflows](docs/api/sdk/workflows.md) · [Tasks](docs/api/sdk/tasks.md) · [Escalations](docs/api/sdk/escalations.md) · [YAML Workflows](docs/api/sdk/yaml-workflows.md) · [MCP](docs/api/sdk/mcp.md) · [Events](docs/api/sdk/events.md)
 

package/build/api/index.d.ts

@@ -6,7 +6,8 @@ export * as users from './users';
 export * as roles from './roles';
 export * as auth from './auth';
 export * as mcp from './mcp';
-export * as mcpRuns from './mcp-runs';
+export * as pipelines from './pipelines';
+export * as mcpRuns from './pipelines';
 export * as insight from './insight';
 export * as settings from './settings';
 export * as exports from './exports';

package/build/api/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.maintenance = exports.namespaces = exports.dba = exports.workflowSets = exports.botAccounts = exports.controlplane = exports.exports = exports.settings = exports.insight = exports.mcpRuns = exports.mcp = exports.auth = exports.roles = exports.users = exports.yamlWorkflows = exports.workflows = exports.escalations = exports.tasks = void 0;
+exports.maintenance = exports.namespaces = exports.dba = exports.workflowSets = exports.botAccounts = exports.controlplane = exports.exports = exports.settings = exports.insight = exports.mcpRuns = exports.pipelines = exports.mcp = exports.auth = exports.roles = exports.users = exports.yamlWorkflows = exports.workflows = exports.escalations = exports.tasks = void 0;
 exports.tasks = __importStar(require("./tasks"));
 exports.escalations = __importStar(require("./escalations"));
 exports.workflows = __importStar(require("./workflows"));
@@ -42,7 +42,8 @@ exports.users = __importStar(require("./users"));
 exports.roles = __importStar(require("./roles"));
 exports.auth = __importStar(require("./auth"));
 exports.mcp = __importStar(require("./mcp"));
-exports.mcpRuns = __importStar(require("./mcp-runs"));
+exports.pipelines = __importStar(require("./pipelines"));
+exports.mcpRuns = __importStar(require("./pipelines")); // backward-compat alias
 exports.insight = __importStar(require("./insight"));
 exports.settings = __importStar(require("./settings"));
 exports.exports = __importStar(require("./exports"));

package/build/api/{mcp-runs.d.ts → pipelines.d.ts}

@@ -43,3 +43,21 @@ export declare function getJobExecution(input: {
     jobId: string;
     app_id: string;
 }): Promise<LTApiResult>;
+/**
+ * Interrupt a running pipeline job via HotMesh.interrupt().
+ *
+ * This is the pipeline equivalent of the durable terminate endpoint.
+ * Pipelines run as raw HotMesh YAML DAGs, not through the Durable
+ * abstraction, so they require the app_id (namespace) and topic
+ * to locate the correct engine instance.
+ *
+ * @param input.jobId — HotMesh job ID (workflow_id)
+ * @param input.topic — workflow entity/topic name
+ * @param input.app_id — HotMesh namespace (e.g. "hmsh", "longtail")
+ * @returns `{ status: 200, data: { interrupted: true } }` or error
+ */
+export declare function interruptJob(input: {
+    jobId: string;
+    topic: string;
+    app_id: string;
+}): Promise<LTApiResult>;

package/build/api/{mcp-runs.js → pipelines.js}

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.listEntities = listEntities;
 exports.listJobs = listJobs;
 exports.getJobExecution = getJobExecution;
+exports.interruptJob = interruptJob;
 const hotmesh_utils_1 = require("../services/hotmesh-utils");
-const mcp_runs_1 = require("../services/mcp-runs");
+const pipelines_1 = require("../services/pipelines");
+const controlplane_1 = require("../services/controlplane");
 /**
  * List distinct entity types for an app (HotMesh namespace).
  *
@@ -16,7 +18,7 @@ async function listEntities(input) {
         if (!input.app_id) {
             return { status: 400, error: 'app_id query parameter is required' };
         }
-        const entities = await (0, mcp_runs_1.listEntities)(input.app_id);
+        const entities = await (0, pipelines_1.listEntities)(input.app_id);
         return { status: 200, data: { entities } };
     }
     catch (err) {
@@ -42,7 +44,7 @@ async function listJobs(input) {
         if (!input.app_id) {
             return { status: 400, error: 'app_id query parameter is required' };
         }
-        const result = await (0, mcp_runs_1.listJobs)({
+        const result = await (0, pipelines_1.listJobs)({
             rawAppId: input.app_id,
             limit: input.limit,
             offset: input.offset,
@@ -78,7 +80,7 @@ async function getJobExecution(input) {
         }
         const appId = (0, hotmesh_utils_1.sanitizeAppId)(input.app_id);
         const schema = (0, hotmesh_utils_1.quoteSchema)(appId);
-        const execution = await (0, mcp_runs_1.buildExecution)(input.jobId, appId, schema);
+        const execution = await (0, pipelines_1.buildExecution)(input.jobId, appId, schema);
         return { status: 200, data: execution };
     }
     catch (err) {
@@ -89,3 +91,33 @@ async function getJobExecution(input) {
         return { status: 500, error: msg };
     }
 }
+/**
+ * Interrupt a running pipeline job via HotMesh.interrupt().
+ *
+ * This is the pipeline equivalent of the durable terminate endpoint.
+ * Pipelines run as raw HotMesh YAML DAGs, not through the Durable
+ * abstraction, so they require the app_id (namespace) and topic
+ * to locate the correct engine instance.
+ *
+ * @param input.jobId — HotMesh job ID (workflow_id)
+ * @param input.topic — workflow entity/topic name
+ * @param input.app_id — HotMesh namespace (e.g. "hmsh", "longtail")
+ * @returns `{ status: 200, data: { interrupted: true } }` or error
+ */
+async function interruptJob(input) {
+    try {
+        if (!input.app_id) {
+            return { status: 400, error: 'app_id is required' };
+        }
+        if (!input.topic) {
+            return { status: 400, error: 'topic is required' };
+        }
+        const appId = (0, hotmesh_utils_1.sanitizeAppId)(input.app_id);
+        const engine = await (0, controlplane_1.getEngine)(appId);
+        await engine.interrupt(input.topic, input.jobId);
+        return { status: 200, data: { interrupted: true, jobId: input.jobId } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}

package/build/api/workflows/discovery.js

@@ -40,7 +40,7 @@ const configService = __importStar(require("../../services/config"));
 const cron_1 = require("../../services/cron");
 const db_1 = require("../../lib/db");
 const registry_1 = require("../../services/workers/registry");
-const sql_1 = require("../../services/mcp-runs/sql");
+const sql_1 = require("../../services/pipelines/sql");
 /**
  * List active workflow workers with their registration status.
  *

package/build/routes/index.js

@@ -20,7 +20,7 @@ const mcp_1 = __importDefault(require("./mcp"));
 const insight_1 = __importDefault(require("./insight"));
 const yaml_workflows_1 = __importDefault(require("./yaml-workflows"));
 const settings_1 = __importDefault(require("./settings"));
-const mcp_runs_1 = __importDefault(require("./mcp-runs"));
+const pipelines_1 = __importDefault(require("./pipelines"));
 const namespaces_1 = __importDefault(require("./namespaces"));
 const files_1 = __importDefault(require("./files"));
 const file_browser_1 = __importDefault(require("./file-browser"));
@@ -54,7 +54,8 @@ router.use('/dba', dba_1.default);
 router.use('/mcp', mcp_1.default);
 router.use('/insight', insight_1.default);
 router.use('/yaml-workflows', yaml_workflows_1.default);
-router.use('/mcp-runs', mcp_runs_1.default);
+router.use('/pipelines', pipelines_1.default);
+router.use('/mcp-runs', pipelines_1.default); // backward-compat alias
 router.use('/namespaces', namespaces_1.default);
 router.use('/file-browser', file_browser_1.default);
 router.use('/controlplane', controlplane_1.default);

package/build/routes/{mcp-runs.js → pipelines.js}

@@ -34,11 +34,11 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = require("express");
-const api = __importStar(require("../api/mcp-runs"));
+const api = __importStar(require("../api/pipelines"));
 const router = (0, express_1.Router)();
 // ── Routes ───────────────────────────────────────────────────────────────────
 /**
- * GET /api/mcp-runs/entities
+ * GET /api/pipelines/entities
  * Return distinct entity (tool) names from {appId}.jobs,
  * supplemented with graph_topics from yaml_workflows for this app_id.
  */
@@ -49,7 +49,7 @@ router.get('/entities', async (req, res) => {
     res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
- * GET /api/mcp-runs
+ * GET /api/pipelines
  * List jobs from {appId}.jobs for a given app_id.
  */
 router.get('/', async (req, res) => {
@@ -66,7 +66,7 @@ router.get('/', async (req, res) => {
     res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
- * GET /api/mcp-runs/:jobId/execution
+ * GET /api/pipelines/:jobId/execution
  * Export execution details for a specific HotMesh pipeline job.
  */
 router.get('/:jobId/execution', async (req, res) => {
@@ -76,4 +76,17 @@ router.get('/:jobId/execution', async (req, res) => {
     });
     res.status(result.status).json(result.data ?? { error: result.error });
 });
+/**
+ * POST /api/pipelines/:jobId/interrupt
+ * Interrupt a running pipeline job via HotMesh.interrupt().
+ * Body: { topic, app_id }
+ */
+router.post('/:jobId/interrupt', async (req, res) => {
+    const result = await api.interruptJob({
+        jobId: req.params.jobId,
+        topic: req.body.topic,
+        app_id: req.body.app_id,
+    });
+    res.status(result.status).json(result.data ?? { error: result.error });
+});
 exports.default = router;

package/build/sdk/index.d.ts

@@ -6,7 +6,7 @@ import * as usersApi from '../api/users';
 import * as rolesApi from '../api/roles';
 import * as authApi from '../api/auth';
 import * as mcpApi from '../api/mcp';
-import * as mcpRunsApi from '../api/mcp-runs';
+import * as pipelinesApi from '../api/pipelines';
 import * as insightApi from '../api/insight';
 import * as settingsApi from '../api/settings';
 import * as exportsApi from '../api/exports';
@@ -241,10 +241,17 @@ export declare function createClient(options?: LTClientOptions): {
             execute_as?: string;
         }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
     };
+    pipelines: {
+        listEntities: typeof pipelinesApi.listEntities;
+        listJobs: typeof pipelinesApi.listJobs;
+        getExecution: typeof pipelinesApi.getJobExecution;
+        interrupt: typeof pipelinesApi.interruptJob;
+    };
+    /** @deprecated Use `pipelines` */
     mcpRuns: {
-        listEntities: typeof mcpRunsApi.listEntities;
-        listJobs: typeof mcpRunsApi.listJobs;
-        getExecution: typeof mcpRunsApi.getJobExecution;
+        listEntities: typeof pipelinesApi.listEntities;
+        listJobs: typeof pipelinesApi.listJobs;
+        getExecution: typeof pipelinesApi.getJobExecution;
     };
     insight: {
         mcpQuery: (input: {

package/build/sdk/index.js

@@ -42,7 +42,7 @@ const usersApi = __importStar(require("../api/users"));
 const rolesApi = __importStar(require("../api/roles"));
 const authApi = __importStar(require("../api/auth"));
 const mcpApi = __importStar(require("../api/mcp"));
-const mcpRunsApi = __importStar(require("../api/mcp-runs"));
+const pipelinesApi = __importStar(require("../api/pipelines"));
 const insightApi = __importStar(require("../api/insight"));
 const settingsApi = __importStar(require("../api/settings"));
 const exportsApi = __importStar(require("../api/exports"));
@@ -208,11 +208,18 @@ function createClient(options = {}) {
             listTools: mcpApi.listMcpServerTools,
             callTool: bindOptionalAuth(mcpApi.callMcpTool, auth),
         },
-        // ── MCP Runs ───────────────────────────────────────────────────────────
+        // ── Pipelines ──────────────────────────────────────────────────────────
+        pipelines: {
+            listEntities: pipelinesApi.listEntities,
+            listJobs: pipelinesApi.listJobs,
+            getExecution: pipelinesApi.getJobExecution,
+            interrupt: pipelinesApi.interruptJob,
+        },
+        /** @deprecated Use `pipelines` */
         mcpRuns: {
-            listEntities: mcpRunsApi.listEntities,
-            listJobs: mcpRunsApi.listJobs,
-            getExecution: mcpRunsApi.getJobExecution,
+            listEntities: pipelinesApi.listEntities,
+            listJobs: pipelinesApi.listJobs,
+            getExecution: pipelinesApi.getJobExecution,
         },
         // ── Insight ────────────────────────────────────────────────────────────
         insight: {

package/build/services/{mcp-runs → pipelines}/sql.js

@@ -1,5 +1,5 @@
 "use strict";
-// SQL templates for mcp-runs queries.
+// SQL templates for pipeline queries.
 // Schema placeholders (${schema}) are interpolated at call time
 // because Postgres does not support parameterized schema names.
 Object.defineProperty(exports, "__esModule", { value: true });

package/build/start/adapters.js

@@ -56,14 +56,11 @@ function registerAdapters(startConfig) {
     // CallbackEventAdapter is registered later in start/workers.ts
     // so it can be wired to the NATS bridge before connect().
     // Do NOT register a duplicate here.
-    // Maintenance
-    if (startConfig.maintenance === false) {
-        // Disabled
-    }
-    else if (startConfig.maintenance === true || startConfig.maintenance === undefined) {
+    // Maintenance — opt-in only. Pass `true` for defaults or a config object.
+    if (startConfig.maintenance === true) {
         maintenance_1.maintenanceRegistry.register(maintenance_2.defaultMaintenanceConfig);
     }
-    else {
+    else if (startConfig.maintenance) {
         maintenance_1.maintenanceRegistry.register(startConfig.maintenance);
     }
     // Escalation strategy

package/build/start/server.js

@@ -31,9 +31,12 @@ function startServer() {
     const dashboardDist = (0, fs_1.existsSync)(devDist) ? devDist : prodDist;
     if ((0, fs_1.existsSync)(dashboardDist)) {
         app.use(express_1.default.static(dashboardDist));
-        // SPA fallback — all non-API routes serve index.html
+        // SPA fallback — inject <base href="/"> so relative asset paths
+        // resolve from root regardless of route depth (e.g. /admin/users).
+        const rawHtml = (0, fs_1.readFileSync)(path_1.default.join(dashboardDist, 'index.html'), 'utf-8');
+        const indexHtml = rawHtml.replace('<head>', '<head><base href="/">');
         app.get('/{*splat}', (_req, res) => {
-            res.sendFile(path_1.default.join(dashboardDist, 'index.html'));
+            res.type('html').send(indexHtml);
         });
         logger_1.loggerRegistry.info(`[long-tail] Dashboard: http://localhost:${config_1.config.PORT}/`);
     }