@nettee/beacon 0.4.10 → 0.5.0

package/README.md

@@ -109,6 +109,34 @@ created by Beacon 0.1.2 and earlier; when omitted it defaults to `sessions/`
 beside `config.yaml`. When configured, it must be absolute. Beacon creates
 per-Run directories with mode `0700` when Pi starts.
 
+Run admission splits host ceiling vs per-Profile budgets.
+`runs.max_concurrent` in `config.yaml` is a **host-wide ceiling** on
+simultaneously active Runs. Each Profile has its own concurrency budget and
+queue lane (so one Profile cannot exhaust another's capacity). Set per-Profile
+limits on that Profile's `profile.yaml`; omit them to use
+`runs.default_max_concurrent` (default `1`) and `runs.max_queued`:
+
+```yaml
+# ~/.beacon/config.yaml
+runs:
+  max_concurrent: 3
+  max_queued: 100
+  default_max_concurrent: 1
+  timeout_seconds: 1800
+  terminate_grace_seconds: 5
+```
+
+```yaml
+# ~/.beacon/profiles/alert-diagnoser/profile.yaml
+max_concurrent: 2
+# max_queued: 40   # optional; omit → runs.max_queued
+```
+
+Per-Profile `max_concurrent` must not exceed the global ceiling (`beacon doctor`
+and startup both reject that). Event Triggers still wait via
+`enqueueWhenAvailable` instead of failing with `capacity_exceeded` when their
+lane is full.
+
 Configuration is strict: unknown YAML/JSON fields, YAML aliases or warnings, missing paths, duplicate Schedule IDs, invalid timezones/cron expressions, a missing complete `persona.md` + `task.md` pair, escaped Profile markdown, permissive secret or runtime-environment permissions, missing Profile credentials, and unknown Feishu channel names all fail startup. Beacon validates all Profiles before opening a Feishu connection.
 
 Group notify destinations are registered globally in `~/.beacon/channels.yaml`
@@ -306,7 +334,8 @@ pending dispatch without rematching historical events, and each recipient
 Profile is claimed once. Changing a listener affects only new events. Keep
 Profiles referenced by pending receipts configured until dispatch settles;
 removing one causes a visible fatal dispatch failure. Dispatch is serial and
-waits for the shared Run queue, while HTTP acceptance remains independent.
+waits for that Profile's Run queue lane (under the host-wide active ceiling),
+while HTTP acceptance remains independent.
 Active Runs interrupted by restart fail rather than execute twice; failed Runs
 are not retried automatically or retriggered by duplicate event delivery. Event
 records, like existing state records, have no automatic retention cleanup;

package/dist/daemon/config/global.d.ts

@@ -11,8 +11,12 @@ export type GlobalConfig = {
         sessionDirectory: string;
     };
     runs: {
+        /** Host-wide ceiling on simultaneously active Runs across all Profiles. */
         maxConcurrent: number;
+        /** Default per-Profile queue depth (each Profile has an isolated queue). */
         maxQueued: number;
+        /** Default per-Profile concurrency when Profile yaml omits `max_concurrent`. */
+        defaultMaxConcurrent: number;
         timeoutSeconds: number;
         terminateGraceSeconds: number;
     };

package/dist/daemon/config/global.js

@@ -4,6 +4,36 @@ import { dirname, isAbsolute, join, resolve } from "node:path";
 import { z } from "zod";
 import { parseStrictYaml } from "./yaml.js";
 const positiveInteger = z.number().int().positive().safe();
+const nonNegativeInteger = z.number().int().nonnegative().safe();
+const runsDocumentSchema = z
+    .object({
+    /** Host-wide ceiling on simultaneously active Runs across all Profiles. */
+    max_concurrent: positiveInteger,
+    /**
+     * Default per-Profile queue depth. Each Profile has its own queue so one
+     * Profile cannot exhaust another's capacity. Override on Profile yaml with
+     * `max_queued`.
+     */
+    max_queued: nonNegativeInteger,
+    /**
+     * Default per-Profile concurrency when Profile yaml omits `max_concurrent`.
+     * Defaults to 1.
+     */
+    default_max_concurrent: positiveInteger.optional(),
+    timeout_seconds: positiveInteger,
+    terminate_grace_seconds: positiveInteger,
+})
+    .strict()
+    .superRefine((runs, context) => {
+    const defaultMax = runs.default_max_concurrent ?? 1;
+    if (defaultMax > runs.max_concurrent) {
+        context.addIssue({
+            code: "custom",
+            message: "runs.default_max_concurrent must be <= runs.max_concurrent (global ceiling)",
+            path: ["default_max_concurrent"],
+        });
+    }
+});
 const globalDocumentSchema = z
     .object({
     version: z.literal(1),
@@ -15,14 +45,7 @@ const globalDocumentSchema = z
         session_directory: z.string().min(1).optional(),
     })
         .strict(),
-    runs: z
-        .object({
-        max_concurrent: positiveInteger,
-        max_queued: z.number().int().nonnegative().safe(),
-        timeout_seconds: positiveInteger,
-        terminate_grace_seconds: positiveInteger,
-    })
-        .strict(),
+    runs: runsDocumentSchema,
     scheduler: z
         .object({ max_occurrences_per_reconciliation: positiveInteger })
         .strict(),
@@ -112,6 +135,7 @@ export async function loadGlobalConfig(path) {
         runs: {
             maxConcurrent: document.runs.max_concurrent,
             maxQueued: document.runs.max_queued,
+            defaultMaxConcurrent: document.runs.default_max_concurrent ?? 1,
             timeoutSeconds: document.runs.timeout_seconds,
             terminateGraceSeconds: document.runs.terminate_grace_seconds,
         },

package/dist/daemon/config/profile.d.ts

@@ -25,6 +25,10 @@ export type Profile = {
         provider: string;
         id: string;
     };
+    /** Per-Profile active Run limit from profile.yaml; omit → host default. */
+    maxConcurrent?: number | undefined;
+    /** Per-Profile queue depth from profile.yaml; omit → host `runs.max_queued`. */
+    maxQueued?: number | undefined;
     admin?: DeliveryDestination | undefined;
     listener?: EventListener | undefined;
     schedules: Array<{

package/dist/daemon/config/profile.js

@@ -61,6 +61,8 @@ const skillsSchema = z
     paths: z.array(z.string().trim().min(1)).default([]),
 })
     .strict();
+const positiveInteger = z.number().int().positive().safe();
+const nonNegativeInteger = z.number().int().nonnegative().safe();
 const profileDocumentSchema = z
     .object({
     playbook: z.string().min(1),
@@ -71,6 +73,17 @@ const profileDocumentSchema = z
         id: z.string().min(1),
     })
         .strict(),
+    /**
+     * Optional per-Profile active Run limit. When omitted, the host uses
+     * `runs.default_max_concurrent` from global config (default 1). Must not
+     * exceed global `runs.max_concurrent`.
+     */
+    max_concurrent: positiveInteger.optional(),
+    /**
+     * Optional per-Profile queue depth. When omitted, the host uses
+     * `runs.max_queued` from global config. Queues are isolated per Profile.
+     */
+    max_queued: nonNegativeInteger.optional(),
     admin: adminDestinationSchema.optional(),
     schedules: z.array(scheduleSchema).default([]),
     listener: z
@@ -293,6 +306,12 @@ export async function loadProfile(profileId, profilesDirectory = join(homedir(),
         playbook,
         runtime: config.runtime,
         model: config.model,
+        ...(config.max_concurrent !== undefined
+            ? { maxConcurrent: config.max_concurrent }
+            : {}),
+        ...(config.max_queued !== undefined
+            ? { maxQueued: config.max_queued }
+            : {}),
         ...(admin ? { admin } : {}),
         ...(config.listener
             ? {

package/dist/daemon/doctor.js

@@ -5,12 +5,15 @@ import { loadProfileRegistry } from "./config/registry.js";
 import { loadRuntimeEnvironment } from "./config/runtime-environment.js";
 import { loadFeishuCredentials } from "./config/secrets.js";
 import { createFeishuGateway } from "./feishu/gateway.js";
+import { profileLimitsFromProfiles } from "./run/queue.js";
 import { runPiAgent } from "./runtime/pi-rpc.js";
 export async function runDoctor(configPath) {
     const global = await loadGlobalConfig(configPath);
     const runtimeEnvironment = await loadRuntimeEnvironment(global.runtimeEnvironmentPath);
     const channels = await loadChannelRegistry(global.channelsPath);
     const profiles = await loadProfileRegistry(global.profilesDirectory, channels, global.channelsPath);
+    // Fail fast if any Profile concurrency exceeds the host-wide ceiling.
+    profileLimitsFromProfiles(profiles, global.runs);
     if (global.events)
         await loadEventCredentials(global.events.credentialsPath);
     for (const profile of profiles) {

package/dist/daemon/manual-trigger.js

@@ -6,7 +6,7 @@ import { loadRuntimeEnvironment } from "./config/runtime-environment.js";
 import { renderDeliveryAsText } from "./outcome/content.js";
 import { startOutcomeServer } from "./outcome/server.js";
 import { createPiRunOrchestrator } from "./run/create-pi-orchestrator.js";
-import { RunQueue } from "./run/queue.js";
+import { createRunQueue } from "./run/queue.js";
 import { TriggerStore } from "./state/trigger-store.js";
 function writeStdout(text) {
     return new Promise((resolve, reject) => {
@@ -46,7 +46,7 @@ export async function runManualTrigger(configPath, profileId, input, options, ou
             runtimeEnvironment,
             profile,
             store,
-            queue: new RunQueue(global.runs.maxConcurrent, global.runs.maxQueued),
+            queue: createRunQueue(global.runs, [profile]),
             outcomes,
             delivery,
         });

package/dist/daemon/run/orchestrator.js

@@ -448,10 +448,10 @@ export class RunOrchestrator {
             run: this.newRun(runId, "queued", this.triggerFor(current, input), undefined, continued),
         }));
         if (input.kind === "event") {
-            await this.options.queue.enqueueWhenAvailable(() => this.execute(triggerKey, input, runId));
+            await this.options.queue.enqueueWhenAvailable(this.options.profile.id, () => this.execute(triggerKey, input, runId));
             return;
         }
-        const queued = this.options.queue.enqueue(() => this.execute(triggerKey, input, runId));
+        const queued = this.options.queue.enqueue(this.options.profile.id, () => this.execute(triggerKey, input, runId));
         if (!queued.accepted) {
             await this.fail(triggerKey, runId, "capacity_exceeded", "Run queue capacity exceeded");
             return;
@@ -488,10 +488,10 @@ export class RunOrchestrator {
             }
             if (latest.run?.state === "queued" && latest.input) {
                 if (latest.input.kind === "event") {
-                    await this.options.queue.enqueueWhenAvailable(() => this.execute(latest.triggerKey, latest.input, latest.run.runId));
+                    await this.options.queue.enqueueWhenAvailable(this.options.profile.id, () => this.execute(latest.triggerKey, latest.input, latest.run.runId));
                     continue;
                 }
-                const queued = this.options.queue.enqueue(() => this.execute(latest.triggerKey, latest.input, latest.run.runId));
+                const queued = this.options.queue.enqueue(this.options.profile.id, () => this.execute(latest.triggerKey, latest.input, latest.run.runId));
                 if (!queued.accepted) {
                     throw new Error("Persisted queued Runs exceed configured queue capacity");
                 }

package/dist/daemon/run/queue.d.ts

@@ -4,17 +4,64 @@ export type QueueSubmission = {
     accepted: true;
     completion: Promise<void>;
 };
+export type ProfileRunLimits = {
+    maxConcurrent: number;
+    maxQueued?: number | undefined;
+};
+export type RunQueueOptions = {
+    /** Global ceiling on simultaneously active runs across all profiles. */
+    maxConcurrent: number;
+    /** Default per-profile queue depth when a profile does not override max_queued. */
+    maxQueued: number;
+    /**
+     * Default per-profile concurrency when Profile yaml omits `max_concurrent`.
+     * Defaults to 1.
+     */
+    defaultMaxConcurrent?: number | undefined;
+    /** Per-profile limits from Profile yaml, keyed by Profile ID. */
+    profiles?: Readonly<Record<string, ProfileRunLimits>> | undefined;
+};
+export type ProfileRunLimitSource = {
+    id: string;
+    maxConcurrent?: number | undefined;
+    maxQueued?: number | undefined;
+};
+export type RunAdmissionDefaults = {
+    maxConcurrent: number;
+    maxQueued: number;
+    defaultMaxConcurrent: number;
+};
+/**
+ * Build per-profile queue limits from loaded Profiles and reject any Profile
+ * whose effective concurrency exceeds the host-wide ceiling.
+ */
+export declare function profileLimitsFromProfiles(profiles: readonly ProfileRunLimitSource[], defaults: Pick<RunAdmissionDefaults, "maxConcurrent" | "defaultMaxConcurrent">): Record<string, ProfileRunLimits>;
+/** Construct a RunQueue from global runs defaults + loaded Profiles. */
+export declare function createRunQueue(defaults: RunAdmissionDefaults, profiles: readonly ProfileRunLimitSource[]): RunQueue;
+/**
+ * Multi-lane Run admission: each Profile has its own concurrency and queue
+ * budget so one Profile cannot exhaust another's slots. `maxConcurrent` is a
+ * host-wide ceiling across all active Runs.
+ */
 export declare class RunQueue {
     readonly maxConcurrent: number;
     readonly maxQueued: number;
-    private active;
+    readonly defaultMaxConcurrent: number;
+    private readonly profileLimits;
+    private globalActive;
     private readonly pending;
-    private readonly waiting;
-    constructor(maxConcurrent: number, maxQueued: number);
-    enqueue(task: () => Promise<void>): QueueSubmission;
+    private readonly lanes;
+    constructor(options: RunQueueOptions);
+    limitsFor(profileId: string): {
+        maxConcurrent: number;
+        maxQueued: number;
+    };
+    enqueue(profileId: string, task: () => Promise<void>): QueueSubmission;
     /** Wait for admission without dropping already accepted, persisted event work. */
-    enqueueWhenAvailable(task: () => Promise<void>): Promise<void>;
+    enqueueWhenAvailable(profileId: string, task: () => Promise<void>): Promise<void>;
+    private lane;
     private promoteWaiting;
+    private promoteAllWaiting;
     private execute;
     private drain;
 }

package/dist/daemon/run/queue.js

@@ -1,22 +1,92 @@
+/**
+ * Build per-profile queue limits from loaded Profiles and reject any Profile
+ * whose effective concurrency exceeds the host-wide ceiling.
+ */
+export function profileLimitsFromProfiles(profiles, defaults) {
+    const limits = {};
+    for (const profile of profiles) {
+        const maxConcurrent = profile.maxConcurrent ?? defaults.defaultMaxConcurrent;
+        if (maxConcurrent > defaults.maxConcurrent) {
+            throw new Error(`Profile ${profile.id} max_concurrent (${String(maxConcurrent)}) exceeds runs.max_concurrent (${String(defaults.maxConcurrent)})`);
+        }
+        if (profile.maxConcurrent !== undefined ||
+            profile.maxQueued !== undefined) {
+            limits[profile.id] = {
+                maxConcurrent,
+                ...(profile.maxQueued !== undefined
+                    ? { maxQueued: profile.maxQueued }
+                    : {}),
+            };
+        }
+    }
+    return limits;
+}
+/** Construct a RunQueue from global runs defaults + loaded Profiles. */
+export function createRunQueue(defaults, profiles) {
+    return new RunQueue({
+        maxConcurrent: defaults.maxConcurrent,
+        maxQueued: defaults.maxQueued,
+        defaultMaxConcurrent: defaults.defaultMaxConcurrent,
+        profiles: profileLimitsFromProfiles(profiles, defaults),
+    });
+}
+function assertPositiveInteger(name, value) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new Error(`${name} must be a positive integer`);
+    }
+}
+function assertNonNegativeInteger(name, value) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`${name} must be a non-negative integer`);
+    }
+}
+/**
+ * Multi-lane Run admission: each Profile has its own concurrency and queue
+ * budget so one Profile cannot exhaust another's slots. `maxConcurrent` is a
+ * host-wide ceiling across all active Runs.
+ */
 export class RunQueue {
     maxConcurrent;
     maxQueued;
-    active = 0;
+    defaultMaxConcurrent;
+    profileLimits;
+    globalActive = 0;
     pending = [];
-    waiting = [];
-    constructor(maxConcurrent, maxQueued) {
-        this.maxConcurrent = maxConcurrent;
-        this.maxQueued = maxQueued;
-        if (!Number.isSafeInteger(maxConcurrent) || maxConcurrent <= 0) {
-            throw new Error("maxConcurrent must be a positive integer");
+    lanes = new Map();
+    constructor(options) {
+        assertPositiveInteger("maxConcurrent", options.maxConcurrent);
+        assertNonNegativeInteger("maxQueued", options.maxQueued);
+        const defaultMaxConcurrent = options.defaultMaxConcurrent ?? 1;
+        assertPositiveInteger("defaultMaxConcurrent", defaultMaxConcurrent);
+        if (defaultMaxConcurrent > options.maxConcurrent) {
+            throw new Error("defaultMaxConcurrent must be <= maxConcurrent (global ceiling)");
         }
-        if (!Number.isSafeInteger(maxQueued) || maxQueued < 0) {
-            throw new Error("maxQueued must be a non-negative integer");
+        for (const [profileId, limits] of Object.entries(options.profiles ?? {})) {
+            assertPositiveInteger(`profiles.${profileId}.maxConcurrent`, limits.maxConcurrent);
+            if (limits.maxConcurrent > options.maxConcurrent) {
+                throw new Error(`profiles.${profileId}.maxConcurrent must be <= maxConcurrent (global ceiling)`);
+            }
+            if (limits.maxQueued !== undefined) {
+                assertNonNegativeInteger(`profiles.${profileId}.maxQueued`, limits.maxQueued);
+            }
         }
+        this.maxConcurrent = options.maxConcurrent;
+        this.maxQueued = options.maxQueued;
+        this.defaultMaxConcurrent = defaultMaxConcurrent;
+        this.profileLimits = options.profiles ?? {};
     }
-    enqueue(task) {
-        if (this.active >= this.maxConcurrent &&
-            this.pending.length >= this.maxQueued) {
+    limitsFor(profileId) {
+        const override = this.profileLimits[profileId];
+        return {
+            maxConcurrent: override?.maxConcurrent ?? this.defaultMaxConcurrent,
+            maxQueued: override?.maxQueued ?? this.maxQueued,
+        };
+    }
+    enqueue(profileId, task) {
+        const limits = this.limitsFor(profileId);
+        const lane = this.lane(profileId);
+        if (lane.active >= limits.maxConcurrent &&
+            lane.queued >= limits.maxQueued) {
             return { accepted: false };
         }
         let resolve;
@@ -25,26 +95,50 @@ export class RunQueue {
             resolve = resolvePromise;
             reject = rejectPromise;
         });
-        this.pending.push({ task, resolve, reject });
+        this.pending.push({ profileId, task, resolve, reject });
+        lane.queued += 1;
         this.drain();
         return { accepted: true, completion };
     }
     /** Wait for admission without dropping already accepted, persisted event work. */
-    enqueueWhenAvailable(task) {
+    enqueueWhenAvailable(profileId, task) {
         const completion = new Promise((resolve, reject) => {
-            this.waiting.push({ task, resolve, reject });
+            this.lane(profileId).waiting.push({
+                profileId,
+                task,
+                resolve,
+                reject,
+            });
         });
         this.drain();
         return completion;
     }
-    promoteWaiting() {
-        while (this.waiting.length > 0 &&
-            this.pending.length <
-                this.maxQueued + Math.max(0, this.maxConcurrent - this.active)) {
-            this.pending.push(this.waiting.shift());
+    lane(profileId) {
+        let lane = this.lanes.get(profileId);
+        if (!lane) {
+            lane = { active: 0, queued: 0, waiting: [] };
+            this.lanes.set(profileId, lane);
+        }
+        return lane;
+    }
+    promoteWaiting(profileId) {
+        const limits = this.limitsFor(profileId);
+        const lane = this.lane(profileId);
+        while (lane.waiting.length > 0 &&
+            lane.queued <
+                limits.maxQueued + Math.max(0, limits.maxConcurrent - lane.active)) {
+            const next = lane.waiting.shift();
+            this.pending.push(next);
+            lane.queued += 1;
+        }
+    }
+    promoteAllWaiting() {
+        for (const profileId of this.lanes.keys()) {
+            this.promoteWaiting(profileId);
         }
     }
     async execute(next) {
+        const lane = this.lane(next.profileId);
         try {
             await next.task();
             next.resolve();
@@ -53,18 +147,26 @@ export class RunQueue {
             next.reject(error);
         }
         finally {
-            this.active -= 1;
+            lane.active -= 1;
+            this.globalActive -= 1;
             this.drain();
         }
     }
     drain() {
-        this.promoteWaiting();
-        while (this.active < this.maxConcurrent) {
-            const next = this.pending.shift();
-            if (!next)
+        this.promoteAllWaiting();
+        while (this.globalActive < this.maxConcurrent) {
+            const index = this.pending.findIndex((entry) => {
+                const limits = this.limitsFor(entry.profileId);
+                return this.lane(entry.profileId).active < limits.maxConcurrent;
+            });
+            if (index < 0)
                 return;
-            this.active += 1;
-            this.promoteWaiting();
+            const next = this.pending.splice(index, 1)[0];
+            const lane = this.lane(next.profileId);
+            lane.queued -= 1;
+            lane.active += 1;
+            this.globalActive += 1;
+            this.promoteWaiting(next.profileId);
             void this.execute(next);
         }
     }

package/dist/daemon/schedule-trigger.js

@@ -8,7 +8,7 @@ import { loadFeishuCredentials } from "./config/secrets.js";
 import { createFeishuGateway } from "./feishu/gateway.js";
 import { startOutcomeServer } from "./outcome/server.js";
 import { createPiRunOrchestrator } from "./run/create-pi-orchestrator.js";
-import { RunQueue } from "./run/queue.js";
+import { createRunQueue } from "./run/queue.js";
 import { TriggerStore } from "./state/trigger-store.js";
 function findSchedule(profile, scheduleId) {
     const schedule = profile.schedules.find((candidate) => candidate.id === scheduleId);
@@ -74,7 +74,7 @@ export async function runScheduleTrigger(configPath, profileId, scheduleId, opti
             runtimeEnvironment,
             profile,
             store,
-            queue: new RunQueue(global.runs.maxConcurrent, global.runs.maxQueued),
+            queue: createRunQueue(global.runs, [profile]),
             outcomes,
             delivery: createFeishuGateway(credentials),
         });

package/dist/daemon/service.js

@@ -13,7 +13,7 @@ import { createFeishuGateway } from "./feishu/gateway.js";
 import { createFeishuMessagePipeline } from "./feishu/message-pipeline.js";
 import { startOutcomeServer } from "./outcome/server.js";
 import { createPiRunOrchestrator } from "./run/create-pi-orchestrator.js";
-import { RunQueue } from "./run/queue.js";
+import { createRunQueue } from "./run/queue.js";
 import { ScheduleCursorStore } from "./schedule/cursor-store.js";
 import { ScheduleLoop } from "./schedule/loop.js";
 import { ScheduleReconciler } from "./schedule/reconciler.js";
@@ -45,7 +45,7 @@ export async function runBeacon(configPath, options) {
         ? await loadEventCredentials(global.events.credentialsPath)
         : [];
     const outcomes = await startOutcomeServer();
-    const queue = new RunQueue(global.runs.maxConcurrent, global.runs.maxQueued);
+    const queue = createRunQueue(global.runs, profiles);
     let dashboard;
     try {
         if (global.dashboard.enabled) {

package/examples/config.yaml

@@ -5,8 +5,12 @@ pi:
   coding_agent_directory: /Users/USERNAME/.pi/agent
   session_directory: /Users/USERNAME/.beacon/sessions
 runs:
-  max_concurrent: 2
+  # Host-wide ceiling across all Profiles (active Runs only).
+  max_concurrent: 3
+  # Default per-Profile queue depth (queues are isolated per Profile).
   max_queued: 100
+  # Default per-Profile concurrency when profile.yaml omits max_concurrent.
+  default_max_concurrent: 1
   timeout_seconds: 1800
   terminate_grace_seconds: 5
 scheduler:

package/examples/profiles/example/profile.yaml

@@ -3,6 +3,9 @@ runtime: pi
 model:
   provider: REPLACE_WITH_PI_PROVIDER
   id: REPLACE_WITH_PI_MODEL
+# Optional Run admission (omit → host runs.default_max_concurrent / max_queued).
+# max_concurrent: 1
+# max_queued: 20
 admin:
   chat_id: REPLACE_WITH_ADMIN_DIRECT_CHAT_ID
 schedules:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nettee/beacon",
-  "version": "0.4.10",
+  "version": "0.5.0",
   "description": "A single-host bridge from messaging and schedules to isolated agent runs",
   "license": "Apache-2.0",
   "repository": {