orionfold-relay 0.18.0 → 0.20.0

package/README.md

@@ -104,10 +104,13 @@ The governance is *in* the workflow, not bolted on. A blueprint is a fixed step
 ## Why it stays trustworthy
 
 - **Local-first** — SQLite database, no cloud dependency, `npx orionfold-relay` and go
+- **Never phones home** — no telemetry, no update checks, no license server; the complete outbound-network inventory is documented and code-linked in [docs/trust/data-flow.md](docs/trust/data-flow.md)
 - **Your rules, enforced** — tool permissions, inbox approvals, and audit trails for every agent action
 - **Your AI team** — 21 specialist profiles ready to deploy, each with instructions, tool policies, and runtime tuning
 - **Know what you spend** — usage metering, budgets, and per-provider/per-model spend visibility on governed runs
-- **Open source** — Apache-2.0, read the engine and run it yourself
+- **Open source & verifiable** — Apache-2.0, read the engine and run it yourself; every npm release ships with a provenance attestation and a CycloneDX SBOM ([docs/trust/supply-chain.md](docs/trust/supply-chain.md))
+
+Evaluating Relay for an enterprise? The full trust pack — [security packet](docs/trust/security-packet.md), [data-flow disclosure](docs/trust/data-flow.md), [supply-chain verification](docs/trust/supply-chain.md), [plain-language license terms](docs/trust/license-terms.md), and [continuity statement](docs/trust/continuity.md) — lives in [`docs/trust/`](docs/trust/). Vulnerability reports: [SECURITY.md](SECURITY.md).
 
 <img src="https://raw.githubusercontent.com/orionfold/relay/main/public/readme/inbox-list.png" alt="The governance command center: tool-permission approvals, agent questions, and a permission queue — nothing reaches a client without sign-off" width="1200" />
 
@@ -139,6 +142,9 @@ relay license remove <license-id>                            # forget a license
 - **What's free stays free.** Capabilities never move from the free engine into a paid
   pack. Paid packs are new content, not repossessed features.
 
+The full terms in plain language — seats, transfer, what expiry does and doesn't do —
+are in [docs/trust/license-terms.md](docs/trust/license-terms.md).
+
 ---
 
 ## Runtime bridge

package/dist/cli.js

@@ -1186,7 +1186,7 @@ var CURRENT_PLUGIN_API_VERSION, CAPABILITY_VALUES, ORIGIN_VALUES, PrimitivesBund
 var init_types = __esm({
   "src/lib/plugins/sdk/types.ts"() {
     "use strict";
-    CURRENT_PLUGIN_API_VERSION = "0.17";
+    CURRENT_PLUGIN_API_VERSION = "0.20";
     CAPABILITY_VALUES = ["fs", "net", "child_process", "env"];
     ORIGIN_VALUES = ["ainative-internal", "third-party"];
     PrimitivesBundleManifestSchema = z.object({
@@ -3458,7 +3458,8 @@ async function deleteAppCascade(appId, options = {}) {
     filesRemoved: false,
     projectRemoved: false,
     profilesRemoved: 0,
-    blueprintsRemoved: 0
+    blueprintsRemoved: 0,
+    schedulesRemoved: 0
   };
   const resolvedApps = path2.resolve(appsDir);
   const rootDir = path2.resolve(appsDir, appId);
@@ -3478,7 +3479,23 @@ async function deleteAppCascade(appId, options = {}) {
   const filesRemoved = deleteApp(appId, appsDir);
   const profilesRemoved = sweepNamespacedProfiles(profilesDir, appId);
   const blueprintsRemoved = sweepNamespacedBlueprints(blueprintsDir, appId);
-  return { projectRemoved, filesRemoved, profilesRemoved, blueprintsRemoved };
+  let schedulesRemoved = 0;
+  try {
+    const { db: db3 } = await Promise.resolve().then(() => (init_db(), db_exports));
+    const { schedules: schedules2 } = await Promise.resolve().then(() => (init_schema(), schema_exports));
+    const { like: like8 } = await import("drizzle-orm");
+    const result = db3.delete(schedules2).where(like8(schedules2.id, `app:${appId}:%`)).run();
+    schedulesRemoved = result.changes;
+  } catch (err2) {
+    console.error(`[registry] schedule sweep failed for app "${appId}":`, err2);
+  }
+  return {
+    projectRemoved,
+    filesRemoved,
+    profilesRemoved,
+    blueprintsRemoved,
+    schedulesRemoved
+  };
 }
 var AppArtifactRefSchema, AppBlueprintRefSchema, KitIdSchema, BindingRefSchema, LeafKpiSourceSchema, RatioKpiSourceSchema, KpiSourceSchema, KpiSpecSchema, ViewSchema, AppTableRefSchema, AppScheduleRefSchema, AppManifestSchema, DOW, APPS_CACHE_TTL_MS, appsCache, appsDetailCache, SLUG_RE;
 var init_registry = __esm({
@@ -12411,6 +12428,14 @@ var init_registry5 = __esm({
 });
 
 // src/lib/schedules/installer.ts
+var installer_exports = {};
+__export(installer_exports, {
+  installPluginSchedules: () => installPluginSchedules,
+  installSchedulesFromSpecs: () => installSchedulesFromSpecs,
+  listInstalledPluginScheduleIds: () => listInstalledPluginScheduleIds,
+  removeOrphanSchedules: () => removeOrphanSchedules,
+  removePluginSchedules: () => removePluginSchedules
+});
 import { and as and16, like as like5, notInArray } from "drizzle-orm";
 function pluginScheduleId(pluginId, scheduleId) {
   return `${PLUGIN_SCHEDULE_PREFIX}${pluginId}:${scheduleId}`;
@@ -12508,6 +12533,10 @@ function removeOrphanSchedules(pluginId, keepIds) {
     db.delete(schedules).where(and16(like5(schedules.id, pattern), notInArray(schedules.id, keepIds))).run();
   }
 }
+function listInstalledPluginScheduleIds(pluginId) {
+  const pattern = `${PLUGIN_SCHEDULE_PREFIX}${pluginId}:%`;
+  return db.select({ id: schedules.id }).from(schedules).where(like5(schedules.id, pattern)).all().map((r) => r.id);
+}
 var PLUGIN_SCHEDULE_PREFIX;
 var init_installer = __esm({
   "src/lib/schedules/installer.ts"() {
@@ -12862,7 +12891,7 @@ var init_registry6 = __esm({
     init_registry5();
     init_installer();
     init_schedule_spec();
-    SUPPORTED_API_VERSIONS = /* @__PURE__ */ new Set([CURRENT_PLUGIN_API_VERSION, "0.16"]);
+    SUPPORTED_API_VERSIONS = /* @__PURE__ */ new Set([CURRENT_PLUGIN_API_VERSION, "0.19"]);
     pluginCache = null;
     lastLoadedPluginIds = /* @__PURE__ */ new Set();
     PluginTableSchema = z16.object({
@@ -24900,6 +24929,7 @@ var init_engine = __esm({
 var manifest_trigger_dispatch_exports = {};
 __export(manifest_trigger_dispatch_exports, {
   dispatchBlueprintForRow: () => dispatchBlueprintForRow,
+  dispatchScheduledBlueprint: () => dispatchScheduledBlueprint,
   evaluateManifestTriggers: () => evaluateManifestTriggers
 });
 async function evaluateManifestTriggers(tableId, rowId, rowData) {
@@ -24975,6 +25005,41 @@ async function dispatchBlueprintForRow(input) {
     return null;
   }
 }
+async function dispatchScheduledBlueprint(input) {
+  const { appId, blueprintId, scheduleId } = input;
+  try {
+    const { instantiateBlueprint: instantiateBlueprint2 } = await Promise.resolve().then(() => (init_instantiator(), instantiator_exports));
+    const { executeWorkflow: executeWorkflow2 } = await Promise.resolve().then(() => (init_engine(), engine_exports));
+    const { workflowId } = await instantiateBlueprint2(blueprintId, {}, appId);
+    executeWorkflow2(workflowId).catch((err2) => {
+      console.error(
+        `[manifest-trigger-dispatch] executeWorkflow ${workflowId} failed:`,
+        err2
+      );
+    });
+    return { workflowId };
+  } catch (err2) {
+    const message = err2 instanceof Error ? err2.message : String(err2);
+    console.error(
+      `[manifest-trigger-dispatch] scheduled dispatch failed for app=${appId} blueprint=${blueprintId}:`,
+      err2
+    );
+    try {
+      await db.insert(notifications).values({
+        id: crypto.randomUUID(),
+        taskId: null,
+        type: "task_failed",
+        title: `Schedule failure in app "${appId}"`,
+        body: `Blueprint "${blueprintId}" failed for schedule "${scheduleId}": ${message}`,
+        read: false,
+        createdAt: /* @__PURE__ */ new Date()
+      });
+    } catch (nerr) {
+      console.error(`[manifest-trigger-dispatch] notification write failed:`, nerr);
+    }
+    return null;
+  }
+}
 function findMatchingSubscriptions(apps, tableId) {
   const out = [];
   for (const app of apps) {
@@ -25517,6 +25582,35 @@ var init_tables = __esm({
   }
 });
 
+// src/lib/apps/app-schedule-id.ts
+var app_schedule_id_exports = {};
+__export(app_schedule_id_exports, {
+  APP_SCHEDULE_PREFIX: () => APP_SCHEDULE_PREFIX,
+  appScheduleId: () => appScheduleId,
+  isAppScheduleId: () => isAppScheduleId,
+  parseAppScheduleId: () => parseAppScheduleId
+});
+function appScheduleId(appId, scheduleId) {
+  return `${APP_SCHEDULE_PREFIX}${appId}:${scheduleId}`;
+}
+function isAppScheduleId(id) {
+  return id.startsWith(APP_SCHEDULE_PREFIX);
+}
+function parseAppScheduleId(id) {
+  if (!isAppScheduleId(id)) return null;
+  const rest = id.slice(APP_SCHEDULE_PREFIX.length);
+  const sep = rest.indexOf(":");
+  if (sep <= 0 || sep === rest.length - 1) return null;
+  return { appId: rest.slice(0, sep), scheduleId: rest.slice(sep + 1) };
+}
+var APP_SCHEDULE_PREFIX;
+var init_app_schedule_id = __esm({
+  "src/lib/apps/app-schedule-id.ts"() {
+    "use strict";
+    APP_SCHEDULE_PREFIX = "app:";
+  }
+});
+
 // src/lib/packs/install.ts
 var install_exports = {};
 __export(install_exports, {
@@ -25529,8 +25623,8 @@ import { execFileSync as execFileSync3 } from "child_process";
 import yaml12 from "js-yaml";
 import semver from "semver";
 function relayCoreVersion() {
-  if (semver.valid("0.18.0")) {
-    return "0.18.0";
+  if (semver.valid("0.20.0")) {
+    return "0.20.0";
   }
   try {
     const root = getAppRoot(import.meta.dirname, 3);
@@ -25577,6 +25671,26 @@ async function installPack(source, options = {}) {
       }
     }
     const resolved = resolvePackLayer(pack);
+    const declaredBlueprints = new Set(
+      pack.manifest.blueprints.map((bp) => bp.id)
+    );
+    for (const sched of pack.manifest.schedules) {
+      if (!sched.cron) {
+        throw new PackValidationError(
+          `Manifest schedule "${sched.id}" has no cron expression.`
+        );
+      }
+      if (!sched.runs) {
+        throw new PackValidationError(
+          `Manifest schedule "${sched.id}" has no "runs" blueprint.`
+        );
+      }
+      if (!declaredBlueprints.has(sched.runs)) {
+        throw new PackValidationError(
+          `Manifest schedule "${sched.id}" runs blueprint "${sched.runs}", which the manifest does not declare.`
+        );
+      }
+    }
     const { ensureAppProject: ensureAppProject2 } = await Promise.resolve().then(() => (init_compose_integration(), compose_integration_exports));
     const { ensureCustomer: ensureCustomer2 } = await Promise.resolve().then(() => (init_customers(), customers_exports));
     const { createTable: createTable2, addRows: addRows2, listTables: listTables2 } = await Promise.resolve().then(() => (init_tables(), tables_exports));
@@ -25627,7 +25741,44 @@ async function installPack(source, options = {}) {
       });
       customersSeeded += 1;
     }
-    const droppedManifest = rewriteTableRefs(pack.manifest, logicalToReal);
+    const scheduleLogicalToReal = /* @__PURE__ */ new Map();
+    let schedulesRegistered = 0;
+    if (pack.manifest.schedules.length > 0) {
+      const { appScheduleId: appScheduleId2 } = await Promise.resolve().then(() => (init_app_schedule_id(), app_schedule_id_exports));
+      const { installSchedulesFromSpecs: installSchedulesFromSpecs2 } = await Promise.resolve().then(() => (init_installer(), installer_exports));
+      const specs = pack.manifest.schedules.map((sched) => {
+        const compositeId = appScheduleId2(pack.meta.id, sched.id);
+        scheduleLogicalToReal.set(sched.id, compositeId);
+        const name = typeof sched.name === "string" ? sched.name : titleCase3(sched.id);
+        return {
+          id: compositeId,
+          name: `${name} (${pack.meta.id})`,
+          version: pack.meta.version,
+          // Display-only: the scheduler branches on the app: id prefix and
+          // dispatches the blueprint; this prompt is never sent to an agent.
+          prompt: `App schedule for "${pack.meta.id}" \u2014 runs blueprint "${sched.runs}".`,
+          cronExpression: sched.cron,
+          recurs: true,
+          type: "scheduled"
+        };
+      });
+      installSchedulesFromSpecs2(specs);
+      schedulesRegistered = specs.length;
+      const { db: db3 } = await Promise.resolve().then(() => (init_db(), db_exports));
+      const { schedules: schedulesTable } = await Promise.resolve().then(() => (init_schema(), schema_exports));
+      const { and: and24, inArray: inArray7, isNull: isNull7 } = await import("drizzle-orm");
+      db3.update(schedulesTable).set({ projectId: pack.meta.id }).where(
+        and24(
+          inArray7(schedulesTable.id, specs.map((s) => s.id)),
+          isNull7(schedulesTable.projectId)
+        )
+      ).run();
+    }
+    const droppedManifest = rewriteTableRefs(
+      pack.manifest,
+      logicalToReal,
+      scheduleLogicalToReal
+    );
     if (pack.meta.entitlement) {
       droppedManifest.entitlement = pack.meta.entitlement;
     }
@@ -25637,6 +25788,10 @@ async function installPack(source, options = {}) {
       profilesDir,
       blueprintsDir
     );
+    if (blueprintsDropped > 0) {
+      const { reloadBlueprints: reloadBlueprints2 } = await Promise.resolve().then(() => (init_registry3(), registry_exports3));
+      reloadBlueprints2();
+    }
     return {
       packId: pack.meta.id,
       packVersion: pack.meta.version,
@@ -25645,7 +25800,8 @@ async function installPack(source, options = {}) {
       customersSeeded,
       profilesDropped,
       blueprintsDropped,
-      rowsSeeded
+      rowsSeeded,
+      schedulesRegistered
     };
   } finally {
     cleanup();
@@ -25706,33 +25862,46 @@ function readTableSeed(resolved, logicalId) {
   }
   return [];
 }
-function rewriteTableRefs(manifest, logicalToReal) {
+function rewriteTableRefs(manifest, logicalToReal, scheduleLogicalToReal = /* @__PURE__ */ new Map()) {
   const rewritten = {
     ...manifest,
     tables: manifest.tables.map((t) => {
       const real2 = logicalToReal.get(t.id);
       return real2 ? { ...t, id: real2 } : t;
+    }),
+    // Row-insert triggers bind to tables by the SAME logical id. Dispatch
+    // (manifest-trigger-dispatch) matches trigger.table against the REAL
+    // UUID, so an unrewritten ref silently never fires.
+    blueprints: manifest.blueprints.map((bp) => {
+      const triggerTable = bp.trigger?.table;
+      if (!triggerTable) return bp;
+      const real2 = logicalToReal.get(triggerTable);
+      return real2 ? { ...bp, trigger: { ...bp.trigger, table: real2 } } : bp;
+    }),
+    schedules: manifest.schedules.map((s) => {
+      const real2 = scheduleLogicalToReal.get(s.id);
+      return real2 ? { ...s, id: real2 } : s;
     })
   };
   if (rewritten.view) {
-    rewritten.view = rewriteViewTableRefs(
-      rewritten.view,
-      logicalToReal
-    );
+    rewritten.view = rewriteViewRefs(rewritten.view, {
+      table: logicalToReal,
+      schedule: scheduleLogicalToReal
+    });
   }
   return rewritten;
 }
-function rewriteViewTableRefs(view, logicalToReal) {
+function rewriteViewRefs(view, maps) {
   if (Array.isArray(view)) {
-    return view.map((v) => rewriteViewTableRefs(v, logicalToReal));
+    return view.map((v) => rewriteViewRefs(v, maps));
   }
   if (view && typeof view === "object") {
     const out = {};
     for (const [key, value] of Object.entries(view)) {
-      if (key === "table" && typeof value === "string") {
-        out[key] = logicalToReal.get(value) ?? value;
+      if ((key === "table" || key === "schedule") && typeof value === "string") {
+        out[key] = maps[key].get(value) ?? value;
       } else {
-        out[key] = rewriteViewTableRefs(value, logicalToReal);
+        out[key] = rewriteViewRefs(value, maps);
       }
     }
     return out;
@@ -25832,7 +26001,7 @@ async function runAdd(source, licenseUrl, io) {
       licenseUrl
     });
     io.log(
-      `Installed ${report.packId}@${report.packVersion}: ${report.projectCreated ? "project created" : "project reused"}, ${report.tablesCreated} table(s) (${report.rowsSeeded} row(s)), ${report.customersSeeded} customer(s), ${report.profilesDropped} profile(s), ${report.blueprintsDropped} blueprint(s).`
+      `Installed ${report.packId}@${report.packVersion}: ${report.projectCreated ? "project created" : "project reused"}, ${report.tablesCreated} table(s) (${report.rowsSeeded} row(s)), ${report.customersSeeded} customer(s), ${report.profilesDropped} profile(s), ${report.blueprintsDropped} blueprint(s), ${report.schedulesRegistered} schedule(s).`
     );
     return 0;
   } catch (err2) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orionfold-relay",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "description": "Orionfold Relay — a local-first, multi-agent orchestration runtime and builder scaffold for AI-native work.",
   "keywords": [
     "ai",

package/src/lib/apps/app-schedule-id.ts

@@ -0,0 +1,37 @@
+/**
+ * Composite DB id for app-manifest schedules: `app:<appId>:<scheduleId>`.
+ *
+ * Mirrors the plugin-schedule convention (`plugin:<pluginId>:<specId>`,
+ * src/lib/schedules/installer.ts). A deterministic id makes the install-time
+ * upsert idempotent and lets the scheduler recover the owning app at fire
+ * time without a schema change.
+ *
+ * Kept in its own module (no DB imports) so both the pack installer and the
+ * scheduler can import it statically without touching the runtime-registry
+ * chain (TDR-032).
+ */
+
+export const APP_SCHEDULE_PREFIX = "app:";
+
+export function appScheduleId(appId: string, scheduleId: string): string {
+  return `${APP_SCHEDULE_PREFIX}${appId}:${scheduleId}`;
+}
+
+export function isAppScheduleId(id: string): boolean {
+  return id.startsWith(APP_SCHEDULE_PREFIX);
+}
+
+/**
+ * Recover `{ appId, scheduleId }` from a composite id, or null when the id
+ * is not app-owned. appId is a clean slug (no colons), so the first two
+ * colon-separated segments are unambiguous.
+ */
+export function parseAppScheduleId(
+  id: string
+): { appId: string; scheduleId: string } | null {
+  if (!isAppScheduleId(id)) return null;
+  const rest = id.slice(APP_SCHEDULE_PREFIX.length);
+  const sep = rest.indexOf(":");
+  if (sep <= 0 || sep === rest.length - 1) return null;
+  return { appId: rest.slice(0, sep), scheduleId: rest.slice(sep + 1) };
+}

package/src/lib/apps/manifest-trigger-dispatch.ts

@@ -137,6 +137,63 @@ export async function dispatchBlueprintForRow(input: {
   }
 }
 
+/**
+ * Cron-fired blueprint dispatch for app-manifest schedules
+ * (`manifest.schedules[].runs`). The schedule-side sibling of
+ * `dispatchBlueprintForRow` — same instantiate → execute chokepoint, same
+ * notification-on-failure contract, but with no row context: variables come
+ * entirely from the blueprint's declared defaults, so a pack author must
+ * give every required variable a default for a scheduled blueprint.
+ *
+ * Returns `{ workflowId }` on success, `null` on failure (already logged +
+ * recorded in `notifications`).
+ */
+export async function dispatchScheduledBlueprint(input: {
+  appId: string;
+  blueprintId: string;
+  scheduleId: string;
+}): Promise<{ workflowId: string } | null> {
+  const { appId, blueprintId, scheduleId } = input;
+  try {
+    const { instantiateBlueprint } = await import(
+      "@/lib/workflows/blueprints/instantiator"
+    );
+    const { executeWorkflow } = await import("@/lib/workflows/engine");
+
+    const { workflowId } = await instantiateBlueprint(blueprintId, {}, appId);
+
+    // Fire-and-forget — workflow may run for minutes
+    executeWorkflow(workflowId).catch((err) => {
+      console.error(
+        `[manifest-trigger-dispatch] executeWorkflow ${workflowId} failed:`,
+        err
+      );
+    });
+
+    return { workflowId };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(
+      `[manifest-trigger-dispatch] scheduled dispatch failed for app=${appId} blueprint=${blueprintId}:`,
+      err
+    );
+    try {
+      await db.insert(notifications).values({
+        id: crypto.randomUUID(),
+        taskId: null,
+        type: "task_failed",
+        title: `Schedule failure in app "${appId}"`,
+        body: `Blueprint "${blueprintId}" failed for schedule "${scheduleId}": ${message}`,
+        read: false,
+        createdAt: new Date(),
+      });
+    } catch (nerr) {
+      console.error(`[manifest-trigger-dispatch] notification write failed:`, nerr);
+    }
+    return null;
+  }
+}
+
 interface MatchingSubscription {
   appId: string;
   blueprintId: string;

package/src/lib/apps/registry.ts

@@ -486,6 +486,8 @@ export interface DeleteAppCascadeResult {
   profilesRemoved: number;
   /** Number of `<appId>--*.yaml` blueprint files removed from the blueprints dir. */
   blueprintsRemoved: number;
+  /** Number of `app:<appId>:*` schedule rows removed from the schedules table. */
+  schedulesRemoved: number;
 }
 
 export interface DeleteAppCascadeOptions {
@@ -553,6 +555,7 @@ export async function deleteAppCascade(
     projectRemoved: false,
     profilesRemoved: 0,
     blueprintsRemoved: 0,
+    schedulesRemoved: 0,
   };
 
   const resolvedApps = path.resolve(appsDir);
@@ -577,5 +580,28 @@ export async function deleteAppCascade(
   const profilesRemoved = sweepNamespacedProfiles(profilesDir, appId);
   const blueprintsRemoved = sweepNamespacedBlueprints(blueprintsDir, appId);
 
-  return { projectRemoved, filesRemoved, profilesRemoved, blueprintsRemoved };
+  // Sweep app-owned schedule rows (`app:<appId>:*`, registered by the pack
+  // installer) so an uninstalled app's schedules don't refire into nothing.
+  // Dynamic import — this module must stay out of the DB static import graph.
+  let schedulesRemoved = 0;
+  try {
+    const { db } = await import("@/lib/db");
+    const { schedules } = await import("@/lib/db/schema");
+    const { like } = await import("drizzle-orm");
+    const result = db
+      .delete(schedules)
+      .where(like(schedules.id, `app:${appId}:%`))
+      .run();
+    schedulesRemoved = result.changes;
+  } catch (err) {
+    console.error(`[registry] schedule sweep failed for app "${appId}":`, err);
+  }
+
+  return {
+    projectRemoved,
+    filesRemoved,
+    profilesRemoved,
+    blueprintsRemoved,
+    schedulesRemoved,
+  };
 }

package/src/lib/packs/cli.ts

@@ -104,7 +104,8 @@ async function runAdd(
         `${report.tablesCreated} table(s) (${report.rowsSeeded} row(s)), ` +
         `${report.customersSeeded} customer(s), ` +
         `${report.profilesDropped} profile(s), ` +
-        `${report.blueprintsDropped} blueprint(s).`
+        `${report.blueprintsDropped} blueprint(s), ` +
+        `${report.schedulesRegistered} schedule(s).`
     );
     return 0;
   } catch (err) {