@nettee/beacon 0.3.0 → 0.3.2

package/README.md

@@ -109,11 +109,46 @@ 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.
 
-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, and missing Profile credentials all fail startup. Beacon validates all Profiles before opening a Feishu connection.
+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.
+
+Feishu delivery destinations are registered globally in `~/.beacon/channels.yaml`
+(beside `config.yaml`), then referenced by semantic `name` from each Profile:
+
+```yaml
+# ~/.beacon/channels.yaml
+version: 1
+channels:
+  - name: admin-dm
+    description: Example admin direct chat
+    chat_id: REPLACE_WITH_ADMIN_DIRECT_CHAT_ID
+  - name: weekday-brief-group
+    description: Example weekday brief notify group
+    chat_id: REPLACE_WITH_GROUP_CHAT_ID
+```
+
+```yaml
+# profile.yaml destinations
+admin:
+  name: admin-dm
+schedules:
+  - id: weekday-brief
+    cron: "0 9 * * 1-5"
+    timezone: Asia/Shanghai
+    input: Prepare the weekday brief.
+    notify:
+      name: weekday-brief-group
+```
+
+Each channel has `name` (stable slug), `description` (human-readable Chinese or
+English label), and `chat_id` (the real Feishu chat id). Profile destinations
+bind `name` and may optionally override `description` for local readability;
+Beacon resolves `name` → `chat_id` at load time. Unknown names fail startup.
+Legacy `chat_id` directly under `admin` / `notify` is still accepted so existing
+hosts can migrate one Profile at a time; new Profiles should use `name`.
 
 Each Schedule uses a five-field cron expression and an IANA timezone. Profile
-`admin.chat_id` is the private chat used for schedule `reply_text` /
-`reply_card` / `no_reply` and for failure notices. Optional `notify.chat_id` on a
+`admin` is the private chat used for schedule `reply_text` /
+`reply_card` / `no_reply` and for failure notices. Optional `notify` on a
 Schedule is the group that receives `notify_card`. Beacon deliberately does not
 infer or fall back to another destination. A newly discovered Schedule starts at
 the current time.
@@ -181,19 +216,19 @@ Subscribe in the desired `profile.yaml`:
 
 ```yaml
 admin:
-  chat_id: REPLACE_WITH_ADMIN_DIRECT_CHAT_ID
+  name: admin-dm
 listener:
   sources:
     - https://deploy.example.com/production
   types:
     - com.example.deployment.completed.v1
   notify:
-    chat_id: REPLACE_WITH_GROUP_CHAT_ID
+    name: weekday-brief-group
 ```
 
 Both lists are required and nonempty. Values match exactly: **OR within each
 list, AND between `sources` and `types`**. There are no wildcards, regular
-expressions, or filters inside `data`. A listener requires `admin.chat_id`;
+expressions, or filters inside `data`. A listener requires `admin`;
 `listener.notify` is optional. Matching Profiles each receive one Trigger with
 the complete event as input. Their `persona.md` and `task.md` define what to do.
 `reply_text` and `reply_card` go to the configured admin; `no_reply` is allowed;
@@ -311,7 +346,7 @@ beacon schedule trigger --profile example --schedule daily-report
 
 This creates a distinct durable Run on every invocation and prints its
 `run_id`. It uses the Schedule's configured `input`, replies to
-`admin.chat_id`, and may notify `notify.chat_id`, but does not read, initialize,
+the Profile `admin` channel, and may notify the Schedule `notify` channel, but does not read, initialize,
 or advance the Schedule's cron cursor. Unknown
 Profiles or Schedules and failed Runs or Deliveries exit non-zero; failure
 messages include the `run_id` whenever a Run record was created.
@@ -371,16 +406,27 @@ as Markdown on stdout.
 
 Per-Profile state lives below `profiles/<profile-id>/state/`. Trigger claims, normalized inputs, Run state, Final Outcomes, Delivery state, and Schedule cursors use durable JSON snapshots. Records do not expire, and Beacon has no automatic cleanup task. Manually deleting state also deletes its deduplication memory.
 
-Every new business Run also owns a permanent Pi session. Its Run record stores
-both `sessionId` and `sessionPath`; the session ID is exactly the Beacon
-`runId`, and the path is the dedicated directory
-`<pi.session_directory>/<profile-id>/<runId>/`. Pi receives that mapping via
-`--session-dir`, `--session-id`, and a readable `Beacon <profile-id> <runId>`
-name. The directory contains the Pi JSONL session file and is never cleaned up
-by Beacon. A queued Run keeps the same mapping after restart. Queued records
-written by Beacon 0.1.2 or earlier are assigned the same deterministic mapping
-when recovered. Historical completed records remain readable and may omit the
-two session fields because those Runs were originally ephemeral.
+Every new business Run also owns a permanent Pi session by default. Its Run
+record stores both `sessionId` and `sessionPath`. For a fresh Trigger the
+session ID is exactly the Beacon `runId`, and the path is the dedicated
+directory `<pi.session_directory>/<profile-id>/<runId>/`. Pi receives that
+mapping via `--session-dir`, `--session-id`, and a readable
+`Beacon <profile-id> <runId>` name. The directory contains the Pi JSONL
+session file and is never cleaned up by Beacon. A queued Run keeps the same
+mapping after restart. Queued records written by Beacon 0.1.2 or earlier are
+assigned the same deterministic mapping when recovered. Historical completed
+records remain readable and may omit the two session fields because those Runs
+were originally ephemeral.
+
+When an inbound Feishu message is a quote-reply (`parent_id`) to a message
+Beacon previously delivered (`reply_text` / `reply_card` / `notify_card`, or a
+failure reply), Beacon looks up that outbound Feishu `message_id` on the
+matching Delivery / notify Delivery (`providerRequestId`), then starts a new
+Run that **reuses the prior Pi session** and appends one new user prompt.
+Follow-up Runs keep their own `runId` but set `sessionId` / `sessionPath` to
+the original session. If the quoted message is not a Beacon Delivery, or the
+Delivery did not persist a Feishu `message_id`, Beacon falls back to a fresh
+session.
 
 To locate a session from a reported `run_id`, first find its durable Run
 record, then inspect or export the sole JSONL file in `sessionPath`:

package/dist/config/channels.js

@@ -0,0 +1,65 @@
+import { stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { parseStrictYaml } from "./yaml.js";
+export const channelNamePattern = /^[a-z0-9](?:[a-z0-9_-]{0,62})$/;
+const channelEntrySchema = z
+    .object({
+    name: z
+        .string()
+        .regex(channelNamePattern, "Channel name must be a lowercase slug (a-z, 0-9, _, -)"),
+    description: z.string().trim().min(1),
+    chat_id: z.string().trim().min(1),
+})
+    .strict();
+const channelsDocumentSchema = z
+    .object({
+    version: z.literal(1),
+    channels: z.array(channelEntrySchema).default([]),
+})
+    .strict();
+export function defaultChannelsPath(homeDirectory = join(homedir(), ".beacon")) {
+    return join(homeDirectory, "channels.yaml");
+}
+export function emptyChannelRegistry() {
+    return new Map();
+}
+export async function loadChannelRegistry(path) {
+    const metadata = await stat(path).catch((error) => {
+        if (error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return undefined;
+        }
+        throw new Error(`Cannot inspect Beacon channels file at ${path}`, {
+            cause: error,
+        });
+    });
+    if (!metadata)
+        return emptyChannelRegistry();
+    if (!metadata.isFile()) {
+        throw new Error(`Beacon channels path is not a file: ${path}`);
+    }
+    const document = channelsDocumentSchema.parse(await parseStrictYaml(path));
+    const registry = new Map();
+    for (const entry of document.channels) {
+        if (registry.has(entry.name)) {
+            throw new Error(`Duplicate channel name in ${path}: ${entry.name}`);
+        }
+        registry.set(entry.name, {
+            name: entry.name,
+            description: entry.description,
+            chatId: entry.chat_id,
+        });
+    }
+    return registry;
+}
+export function resolveChannelName(name, channels, channelsPath) {
+    const channel = channels.get(name);
+    if (!channel) {
+        throw new Error(`Unknown Feishu channel name ${JSON.stringify(name)}; define it in ${channelsPath}`);
+    }
+    return channel;
+}

package/dist/config/global.js

@@ -100,6 +100,7 @@ export async function loadGlobalConfig(path) {
         homeDirectory,
         profilesDirectory,
         secretsPath: resolve(homeDirectory, "secrets.json"),
+        channelsPath: resolve(homeDirectory, "channels.yaml"),
         runtimeEnvironmentPath: resolve(homeDirectory, "runtime.env"),
         pi: {
             executable,

package/dist/config/profile.js

@@ -4,11 +4,27 @@ import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { z } from "zod";
 import { eventSourceSchema } from "../events/cloudevent.js";
 import { nextOccurrence } from "../schedule/cron.js";
+import { channelNamePattern, defaultChannelsPath, emptyChannelRegistry, resolveChannelName, } from "./channels.js";
 import { parseStrictYaml } from "./yaml.js";
 const profileIdPattern = /^[a-z0-9](?:[a-z0-9_-]{0,62})$/;
 export const profilePersonaFile = "persona.md";
 export const profileTaskFile = "task.md";
 export const workspaceProfileDirectoryName = ".beacon-profile";
+const namedDestinationSchema = z
+    .object({
+    name: z
+        .string()
+        .regex(channelNamePattern, "Channel name must be a lowercase slug (a-z, 0-9, _, -)"),
+    description: z.string().trim().min(1).optional(),
+})
+    .strict();
+const legacyChatDestinationSchema = z
+    .object({ chat_id: z.string().trim().min(1) })
+    .strict();
+const destinationSchema = z.union([
+    namedDestinationSchema,
+    legacyChatDestinationSchema,
+]);
 const scheduleSchema = z
     .object({
     id: z.string().regex(profileIdPattern),
@@ -31,10 +47,7 @@ const scheduleSchema = z
         }
     }, "Schedule timezone must be a valid IANA timezone"),
     input: z.string().trim().min(1),
-    notify: z
-        .object({ chat_id: z.string().trim().min(1) })
-        .strict()
-        .optional(),
+    notify: destinationSchema.optional(),
 })
     .strict();
 const profileDocumentSchema = z
@@ -47,19 +60,13 @@ const profileDocumentSchema = z
         id: z.string().min(1),
     })
         .strict(),
-    admin: z
-        .object({ chat_id: z.string().trim().min(1) })
-        .strict()
-        .optional(),
+    admin: destinationSchema.optional(),
     schedules: z.array(scheduleSchema).default([]),
     listener: z
         .object({
         sources: z.array(eventSourceSchema).min(1),
         types: z.array(z.string().min(1)).min(1),
-        notify: z
-            .object({ chat_id: z.string().trim().min(1) })
-            .strict()
-            .optional(),
+        notify: destinationSchema.optional(),
     })
         .strict()
         .optional(),
@@ -156,10 +163,23 @@ async function loadPersonaAndTask(profileId, workspace, profileDirectory) {
     ];
     throw new Error(`Profile ${profileId} has no complete ${profilePersonaFile} + ${profileTaskFile} pair. Missing: ${missing.join(", ")}`);
 }
-export async function loadProfile(profileId, profilesDirectory = join(homedir(), ".beacon", "profiles")) {
+function resolveDestination(destination, channels, channelsPath) {
+    if ("chat_id" in destination) {
+        return { chatId: destination.chat_id };
+    }
+    const channel = resolveChannelName(destination.name, channels, channelsPath);
+    return {
+        name: channel.name,
+        description: destination.description ?? channel.description,
+        chatId: channel.chatId,
+    };
+}
+export async function loadProfile(profileId, profilesDirectory = join(homedir(), ".beacon", "profiles"), options = {}) {
     assertProfileId(profileId);
     const profileDirectory = join(profilesDirectory, profileId);
     const configPath = join(profileDirectory, "profile.yaml");
+    const channels = options.channels ?? emptyChannelRegistry();
+    const channelsPath = options.channelsPath ?? defaultChannelsPath(dirname(profilesDirectory));
     const config = profileDocumentSchema.parse(await parseStrictYaml(configPath));
     const scheduleIds = new Set();
     for (const schedule of config.schedules) {
@@ -177,11 +197,14 @@ export async function loadProfile(profileId, profilesDirectory = join(homedir(),
         }
     }
     if (config.schedules.length > 0 && !config.admin) {
-        throw new Error(`Profile ${profileId} with schedules must declare admin.chat_id`);
+        throw new Error(`Profile ${profileId} with schedules must declare admin`);
     }
     if (config.listener && !config.admin) {
-        throw new Error(`Profile ${profileId} with listener must declare admin.chat_id`);
+        throw new Error(`Profile ${profileId} with listener must declare admin`);
     }
+    const admin = config.admin
+        ? resolveDestination(config.admin, channels, channelsPath)
+        : undefined;
     const canonicalProfileDirectory = await realpath(profileDirectory);
     const workspace = isAbsolute(config.workspace)
         ? config.workspace
@@ -207,14 +230,16 @@ export async function loadProfile(profileId, profilesDirectory = join(homedir(),
         workspace,
         runtime: config.runtime,
         model: config.model,
-        ...(config.admin ? { admin: { chatId: config.admin.chat_id } } : {}),
+        ...(admin ? { admin } : {}),
         ...(config.listener
             ? {
                 listener: {
                     sources: config.listener.sources,
                     types: config.listener.types,
                     ...(config.listener.notify
-                        ? { notify: { chatId: config.listener.notify.chat_id } }
+                        ? {
+                            notify: resolveDestination(config.listener.notify, channels, channelsPath),
+                        }
                         : {}),
                 },
             }
@@ -225,14 +250,16 @@ export async function loadProfile(profileId, profilesDirectory = join(homedir(),
             timezone: schedule.timezone,
             input: schedule.input,
             ...(schedule.notify
-                ? { notify: { chatId: schedule.notify.chat_id } }
+                ? {
+                    notify: resolveDestination(schedule.notify, channels, channelsPath),
+                }
                 : {}),
         })),
     };
 }
 export function profileAdminChatId(profile) {
     if (!profile.admin?.chatId) {
-        throw new Error(`Profile ${profile.id} must declare admin.chat_id`);
+        throw new Error(`Profile ${profile.id} must declare admin`);
     }
     return profile.admin.chatId;
 }

package/dist/config/registry.js

@@ -1,6 +1,6 @@
 import { readdir } from "node:fs/promises";
 import { loadProfile } from "./profile.js";
-export async function loadProfileRegistry(profilesDirectory) {
+export async function loadProfileRegistry(profilesDirectory, channels, channelsPath) {
     const entries = await readdir(profilesDirectory, { withFileTypes: true });
     const ids = entries
         .filter((entry) => entry.isDirectory())
@@ -8,5 +8,8 @@ export async function loadProfileRegistry(profilesDirectory) {
         .sort((left, right) => left.localeCompare(right));
     if (ids.length === 0)
         throw new Error(`No Profiles found in ${profilesDirectory}`);
-    return Promise.all(ids.map((id) => loadProfile(id, profilesDirectory)));
+    return Promise.all(ids.map((id) => loadProfile(id, profilesDirectory, {
+        ...(channels ? { channels } : {}),
+        ...(channelsPath ? { channelsPath } : {}),
+    })));
 }

package/dist/dashboard/server.js

@@ -1,6 +1,7 @@
 import { createServer, } from "node:http";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { defaultChannelsPath, loadChannelRegistry, } from "../config/channels.js";
 import { loadProfile } from "../config/profile.js";
 import { buildAgentSystemPrompt, } from "../runtime/system-prompt.js";
 import { exportSessionHtml } from "./export.js";
@@ -40,7 +41,12 @@ async function beaconOwnedSystemPrompt(summary, profilesDirectory) {
     if (summary.systemPrompt)
         return summary.systemPrompt;
     try {
-        return buildAgentSystemPrompt(await loadProfile(summary.profileId, profilesDirectory), triggerFromRunSummary(summary));
+        const channelsPath = defaultChannelsPath(dirname(profilesDirectory));
+        const channels = await loadChannelRegistry(channelsPath);
+        return buildAgentSystemPrompt(await loadProfile(summary.profileId, profilesDirectory, {
+            channels,
+            channelsPath,
+        }), triggerFromRunSummary(summary));
     }
     catch {
         // Old runs without a stored prompt: reconstruction needs a readable Profile.

package/dist/doctor.js

@@ -1,3 +1,4 @@
+import { loadChannelRegistry } from "./config/channels.js";
 import { loadEventCredentials } from "./config/event-credentials.js";
 import { loadGlobalConfig } from "./config/global.js";
 import { loadProfileRegistry } from "./config/registry.js";
@@ -8,7 +9,8 @@ import { runPiAgent } from "./runtime/pi-rpc.js";
 export async function runDoctor(configPath) {
     const global = await loadGlobalConfig(configPath);
     const runtimeEnvironment = await loadRuntimeEnvironment(global.runtimeEnvironmentPath);
-    const profiles = await loadProfileRegistry(global.profilesDirectory);
+    const channels = await loadChannelRegistry(global.channelsPath);
+    const profiles = await loadProfileRegistry(global.profilesDirectory, channels, global.channelsPath);
     if (global.events)
         await loadEventCredentials(global.events.credentialsPath);
     for (const profile of profiles) {

package/dist/feishu/gateway.js

@@ -1,5 +1,10 @@
 import * as Lark from "@larksuiteoapi/node-sdk";
 import { buildFeishuFinalOutcomeCard } from "./final-outcome-card.js";
+/** Prefer Feishu's outbound `message_id` so quote-replies can resume that Run's Pi session. */
+export function providerRequestIdFromMessageSend(result) {
+    const messageId = result.data?.message_id?.trim();
+    return messageId ? { providerRequestId: messageId } : {};
+}
 export function waitForShutdown(signals = process) {
     return new Promise((resolve) => {
         const shutdown = () => {
@@ -121,28 +126,36 @@ export class FeishuGateway {
     async deliver(target, outcome) {
         const message = encodeFeishuFinalOutcome(outcome);
         if (target.kind === "reply") {
-            const result = await this.client.im.v1.message.reply({
+            const result = (await this.client.im.v1.message.reply({
                 path: { message_id: target.messageId },
                 data: {
                     msg_type: message.msgType,
                     content: message.content,
                     reply_in_thread: false,
                 },
-            });
+            }));
             assertSucceeded("deliver quoted reply", result);
-            return {};
+            const provider = providerRequestIdFromMessageSend(result);
+            if (!provider.providerRequestId) {
+                console.error(`[beacon] Feishu quoted reply succeeded without message_id; quote-reply session resume will be unavailable for this Delivery`);
+            }
+            return provider;
         }
         if (target.kind === "chat") {
-            const result = await this.client.im.v1.message.create({
+            const result = (await this.client.im.v1.message.create({
                 params: { receive_id_type: "chat_id" },
                 data: {
                     receive_id: target.chatId,
                     msg_type: message.msgType,
                     content: message.content,
                 },
-            });
+            }));
             assertSucceeded("deliver chat message", result);
-            return {};
+            const provider = providerRequestIdFromMessageSend(result);
+            if (!provider.providerRequestId) {
+                console.error(`[beacon] Feishu chat message succeeded without message_id; quote-reply session resume will be unavailable for this Delivery`);
+            }
+            return provider;
         }
         throw new Error("Feishu Gateway cannot deliver to local stdout");
     }

package/dist/manual-trigger.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { loadChannelRegistry } from "./config/channels.js";
 import { loadGlobalConfig } from "./config/global.js";
 import { loadProfileRegistry } from "./config/registry.js";
 import { loadRuntimeEnvironment } from "./config/runtime-environment.js";
@@ -17,7 +18,8 @@ export async function runManualTrigger(configPath, profileId, input, output = wr
         throw new Error("Manual Trigger input must not be empty");
     const global = await loadGlobalConfig(configPath);
     const runtimeEnvironment = await loadRuntimeEnvironment(global.runtimeEnvironmentPath);
-    const profiles = await loadProfileRegistry(global.profilesDirectory);
+    const channels = await loadChannelRegistry(global.channelsPath);
+    const profiles = await loadProfileRegistry(global.profilesDirectory, channels, global.channelsPath);
     const profile = profiles.find((candidate) => candidate.id === profileId);
     if (!profile)
         throw new Error(`Unknown Profile: ${profileId}`);

package/dist/outcome/doctor.js

@@ -1,4 +1,5 @@
 import { fileURLToPath } from "node:url";
+import { defaultChannelsPath, loadChannelRegistry, } from "../config/channels.js";
 import { loadProfile } from "../config/profile.js";
 import { createProfileRunner } from "../run/profile-runner.js";
 import { startOutcomeServer } from "./server.js";
@@ -13,7 +14,12 @@ const doctorTrigger = {
     },
 };
 export async function runOutcomeDoctor(profileId) {
-    const profile = await loadProfile(profileId);
+    const channelsPath = defaultChannelsPath();
+    const channels = await loadChannelRegistry(channelsPath);
+    const profile = await loadProfile(profileId, undefined, {
+        channels,
+        channelsPath,
+    });
     const outcomes = await startOutcomeServer();
     const beaconCliPath = fileURLToPath(new URL("../../dist/cli.js", import.meta.url));
     try {

package/dist/run/orchestrator.js

@@ -121,6 +121,26 @@ function normalizeAgentOutcome(input, outcome, notifyTarget) {
     }
     return outcome;
 }
+/**
+ * Walk a Feishu quote chain (oldest → newest) from the direct parent backward
+ * and reuse the first Beacon Delivery's Pi session.
+ */
+export async function resolveContinuedPiSession(quotedMessages, findByDeliveredMessageId) {
+    for (let index = quotedMessages.length - 1; index >= 0; index -= 1) {
+        const quoted = quotedMessages[index];
+        const prior = await findByDeliveredMessageId(quoted.messageId);
+        if (!prior?.run?.sessionId || !prior.run.sessionPath)
+            continue;
+        return {
+            sessionId: prior.run.sessionId,
+            sessionPath: prior.run.sessionPath,
+            ...(prior.run.systemPrompt
+                ? { systemPrompt: prior.run.systemPrompt }
+                : {}),
+        };
+    }
+    return undefined;
+}
 export class RunOrchestrator {
     options;
     now;
@@ -150,12 +170,15 @@ export class RunOrchestrator {
     triggerFor(record, input) {
         return agentSystemPromptTrigger(input ?? record.input, record.notifyTarget);
     }
-    newRun(runId, state, trigger, failure) {
+    newRun(runId, state, trigger, failure, continued) {
         const timestamp = this.timestamp();
+        const sessionId = continued?.sessionId ?? runId;
+        const sessionPath = continued?.sessionPath ??
+            join(this.options.sessionDirectory, this.options.profile.id, runId);
         return {
             runId,
-            sessionId: runId,
-            sessionPath: join(this.options.sessionDirectory, this.options.profile.id, runId),
+            sessionId,
+            sessionPath,
             state,
             queuedAt: timestamp,
             ...(state === "failed" ? { finishedAt: timestamp } : {}),
@@ -163,7 +186,7 @@ export class RunOrchestrator {
             model: this.options.profile.model.id,
             workspace: this.options.profile.workspace,
             promptDigest: profilePromptDigest(this.options.profile),
-            systemPrompt: this.agentSystemPrompt(trigger),
+            systemPrompt: continued?.systemPrompt ?? this.agentSystemPrompt(trigger),
             ...(failure ? { failure } : {}),
         };
     }
@@ -363,10 +386,16 @@ export class RunOrchestrator {
             await this.deliverOutcome(triggerKey);
             return;
         }
+        const continued = input.kind === "feishu_message"
+            ? await resolveContinuedPiSession(input.quotedMessages, (messageId) => this.options.store.findByDeliveredMessageId(messageId))
+            : undefined;
+        if (continued) {
+            console.log(`[beacon] resuming Pi session session_id=${continued.sessionId} for trigger_key=${triggerKey} run_id=${runId}`);
+        }
         await this.options.store.update(triggerKey, (current) => ({
             ...current,
             input,
-            run: this.newRun(runId, "queued", this.triggerFor(current, input)),
+            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));

package/dist/schedule-trigger.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { loadChannelRegistry } from "./config/channels.js";
 import { loadGlobalConfig } from "./config/global.js";
 import { profileAdminChatId } from "./config/profile.js";
 import { loadProfileRegistry } from "./config/registry.js";
@@ -57,7 +58,8 @@ export async function triggerScheduleOnce(options) {
 export async function runScheduleTrigger(configPath, profileId, scheduleId) {
     const global = await loadGlobalConfig(configPath);
     const runtimeEnvironment = await loadRuntimeEnvironment(global.runtimeEnvironmentPath);
-    const profiles = await loadProfileRegistry(global.profilesDirectory);
+    const channels = await loadChannelRegistry(global.channelsPath);
+    const profiles = await loadProfileRegistry(global.profilesDirectory, channels, global.channelsPath);
     const profile = profiles.find((candidate) => candidate.id === profileId);
     if (!profile)
         throw new Error(`Unknown Profile: ${profileId}`);

package/dist/service.js

@@ -1,4 +1,5 @@
 import { join } from "node:path";
+import { loadChannelRegistry } from "./config/channels.js";
 import { loadEventCredentials } from "./config/event-credentials.js";
 import { loadGlobalConfig } from "./config/global.js";
 import { loadProfileRegistry } from "./config/registry.js";
@@ -37,7 +38,8 @@ function shutdownController() {
 export async function runBeacon(configPath) {
     const global = await loadGlobalConfig(configPath);
     const runtimeEnvironment = await loadRuntimeEnvironment(global.runtimeEnvironmentPath);
-    const profiles = await loadProfileRegistry(global.profilesDirectory);
+    const channels = await loadChannelRegistry(global.channelsPath);
+    const profiles = await loadProfileRegistry(global.profilesDirectory, channels, global.channelsPath);
     const credentials = await Promise.all(profiles.map((profile) => loadFeishuCredentials(profile.id, global.secretsPath)));
     const eventProducers = global.events
         ? await loadEventCredentials(global.events.credentialsPath)

package/dist/state/trigger-store.js

@@ -139,10 +139,9 @@ function validateRecord(value) {
         throw new Error("Run record must contain both Pi sessionId and sessionPath or neither");
     }
     if (record.run?.sessionId &&
-        (record.run.sessionId !== record.run.runId ||
-            basename(record.run.sessionPath) !== record.run.runId ||
+        (basename(record.run.sessionPath) !== record.run.sessionId ||
             basename(dirname(record.run.sessionPath)) !== record.profileId)) {
-        throw new Error("Run Pi session identity must map to its Profile ID and Run ID");
+        throw new Error("Run Pi session path must map to its Profile ID and session ID");
     }
     if (record.delivery && !record.finalOutcome) {
         throw new Error("Trigger record with Delivery must contain a Final Outcome");
@@ -295,4 +294,25 @@ export class TriggerStore {
         return records.sort((left, right) => left.acceptedAt.localeCompare(right.acceptedAt) ||
             left.triggerId.localeCompare(right.triggerId));
     }
+    /**
+     * Locate the Trigger whose reply or notify Delivery produced this Feishu
+     * outbound `message_id`. Newest accepted Trigger wins on collision.
+     */
+    async findByDeliveredMessageId(messageId) {
+        const trimmed = messageId.trim();
+        if (!trimmed)
+            return undefined;
+        const records = await this.list();
+        for (let index = records.length - 1; index >= 0; index -= 1) {
+            const record = records[index];
+            for (const field of ["delivery", "notifyDelivery"]) {
+                const delivery = record[field];
+                if (delivery?.state === "delivered" &&
+                    delivery.providerRequestId === trimmed) {
+                    return record;
+                }
+            }
+        }
+        return undefined;
+    }
 }

package/examples/channels.yaml.example

@@ -0,0 +1,8 @@
+version: 1
+channels:
+  - name: admin-dm
+    description: Example admin direct chat
+    chat_id: REPLACE_WITH_ADMIN_DIRECT_CHAT_ID
+  - name: weekday-brief-group
+    description: Example weekday brief notify group
+    chat_id: REPLACE_WITH_GROUP_CHAT_ID

package/examples/profiles/example/profile.yaml

@@ -4,14 +4,14 @@ model:
   provider: REPLACE_WITH_PI_PROVIDER
   id: REPLACE_WITH_PI_MODEL
 admin:
-  chat_id: REPLACE_WITH_ADMIN_DIRECT_CHAT_ID
+  name: admin-dm
 schedules:
   - id: weekday-brief
     cron: "0 9 * * 1-5"
     timezone: Asia/Shanghai
     input: Prepare the weekday brief.
     notify:
-      chat_id: REPLACE_WITH_GROUP_CHAT_ID
+      name: weekday-brief-group
 # Optional external event subscription. Both lists use exact matches.
 # listener:
 #   sources:
@@ -19,4 +19,4 @@ schedules:
 #   types:
 #     - com.example.deployment.completed.v1
 #   notify:
-#     chat_id: REPLACE_WITH_GROUP_CHAT_ID
+#     name: weekday-brief-group

package/package.json

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