@nettee/beacon 0.1.9 → 0.1.11

package/README.md

@@ -1,6 +1,6 @@
 # Beacon
 
-Beacon is a single-host service that turns Feishu messages and configured schedules into isolated Pi agent runs. Each accepted Trigger is durably claimed, produces exactly one explicit Final Outcome, and is delivered either as a quoted reply or to a configured Feishu `chat_id`.
+Beacon is a single-host service that turns Feishu messages and configured schedules into isolated Pi agent runs. Each accepted Trigger is durably claimed, produces an explicit Final Outcome, and may `reply` to a person, `notify_card` a group, or stay silent on the admin channel.
 
 This repository currently implements the Feishu + Pi MVP described by the
 [Zest Dev Spec](https://github.com/nettee/beacon/blob/main/specs/change/20260913-beacon-feishu-pi-mvp/spec.md).
@@ -97,7 +97,13 @@ 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, unsafe Prompt paths, permissive secret or runtime-environment permissions, and missing Profile credentials all fail startup. Beacon validates all Profiles before opening a Feishu connection.
 
-Each Schedule uses a five-field cron expression and an IANA timezone. Its `delivery.chat_id` may identify either a direct chat or a group chat; Beacon deliberately does not infer or fall back to another destination. A newly discovered Schedule starts at the current time. After sleep or restart, overdue occurrences are reconciled and coalesced to the most recent one.
+Each Schedule uses a five-field cron expression and an IANA timezone. Profile
+`admin.chat_id` is the private chat used for schedule `reply` / `no_reply` and
+for failure notices. Optional `notify.chat_id` 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.
+After sleep or restart, overdue occurrences are reconciled and coalesced to the
+most recent one.
 
 ## Commands
 
@@ -129,20 +135,24 @@ 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` and `delivery.chat_id`, but
-does not read, initialize, or advance the Schedule's cron cursor. Unknown
+`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,
+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.
 
 ## Final Outcomes
 
-An Agent explicitly calls exactly one of three Final Outcome tools:
+An Agent closes the conversational channel with `reply` or `no_reply`, and may
+also call `notify_card` on the same Run:
 
-- `submit_final_outcome_text` sends a normal Feishu text message.
-- `submit_final_outcome_card` sends an interactive card.
-- `submit_final_outcome_no_reply` completes the Run without creating a
-  Delivery. Its required `reason` is stored for internal audit and is never
-  sent to the user.
+- `reply` sends plain text. Inbound Feishu messages quote-reply the user.
+  Schedules message the Profile admin. Inbound Runs must call `reply`, even
+  when the message is outside the Profile's role.
+- `no_reply` finishes a Schedule without messaging the admin. Its `reason` is
+  stored for audit and is never sent. Do not use it on inbound messages.
+- `notify_card` posts an interactive card to the Schedule's configured group.
+  Inbound messages cannot notify.
 
 The card tool accepts a title, Feishu-compatible Markdown body, and up to five
 HTTP(S) link buttons. The first button is styled as primary. The tools accept
@@ -164,15 +174,15 @@ these argument shapes:
 ```
 
 ```json
-{ "reason": "The group announcement is outside this Profile's role." }
+{ "reason": "No new models to onboard." }
 ```
 
-The selected form is stored durably as part of the Final Outcome. Both quoted
-message replies and scheduled chat messages preserve that choice: text remains
-text, while cards are sent with Feishu's `interactive` message type and include
-the card generation time. A no-reply outcome records a successful Run without
-a Delivery record. Manual local triggers render card outcomes as readable
-Markdown on stdout and print no user-facing content for no-reply outcomes.
+Beacon binds destinations; the Agent never supplies a `chat_id`. Text remains
+text. Cards are sent with Feishu's `interactive` message type and include the
+card generation time. A schedule `no_reply` without `notify_card` records a
+successful Run with no Delivery. Failures `reply` a short error and never
+notify a group. Manual local triggers print reply text and any notify card as
+Markdown on stdout.
 
 ## State and failure behavior
 

package/dist/config/profile.js

@@ -27,7 +27,10 @@ const scheduleSchema = z
         }
     }, "Schedule timezone must be a valid IANA timezone"),
     input: z.string().trim().min(1),
-    delivery: z.object({ chat_id: z.string().trim().min(1) }).strict(),
+    notify: z
+        .object({ chat_id: z.string().trim().min(1) })
+        .strict()
+        .optional(),
 })
     .strict();
 const profileDocumentSchema = z
@@ -41,6 +44,10 @@ const profileDocumentSchema = z
         id: z.string().min(1),
     })
         .strict(),
+    admin: z
+        .object({ chat_id: z.string().trim().min(1) })
+        .strict()
+        .optional(),
     schedules: z.array(scheduleSchema).default([]),
 })
     .strict();
@@ -73,6 +80,9 @@ 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`);
+    }
     if (isAbsolute(config.prompt)) {
         throw new Error(`Profile prompt path must be relative to ${profileDirectory}`);
     }
@@ -115,12 +125,21 @@ export async function loadProfile(profileId, profilesDirectory = join(homedir(),
         workspace,
         runtime: config.runtime,
         model: config.model,
+        ...(config.admin ? { admin: { chatId: config.admin.chat_id } } : {}),
         schedules: config.schedules.map((schedule) => ({
             id: schedule.id,
             cron: schedule.cron,
             timezone: schedule.timezone,
             input: schedule.input,
-            delivery: { chatId: schedule.delivery.chat_id },
+            ...(schedule.notify
+                ? { notify: { chatId: schedule.notify.chat_id } }
+                : {}),
         })),
     };
 }
+export function profileAdminChatId(profile) {
+    if (!profile.admin?.chatId) {
+        throw new Error(`Profile ${profile.id} must declare admin.chat_id`);
+    }
+    return profile.admin.chatId;
+}

package/dist/feishu/gateway.js

@@ -22,9 +22,6 @@ function assertSucceeded(operation, result) {
     }
 }
 export function encodeFeishuFinalOutcome(outcome) {
-    if (outcome.kind === "no_reply") {
-        throw new Error("No-reply Outcomes must not be encoded for Delivery");
-    }
     if (outcome.kind === "text") {
         return {
             msgType: "text",

package/dist/manual-trigger.js

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import { loadGlobalConfig } from "./config/global.js";
 import { loadProfileRegistry } from "./config/registry.js";
 import { loadRuntimeEnvironment } from "./config/runtime-environment.js";
-import { renderFinalOutcomeAsText } from "./outcome/content.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";
@@ -34,7 +34,7 @@ export async function runManualTrigger(configPath, profileId, input, output = wr
                 if (target.kind !== "local_stdout") {
                     throw new Error("Manual Trigger requires local stdout Delivery");
                 }
-                await output(renderFinalOutcomeAsText(outcome));
+                await output(renderDeliveryAsText(outcome));
                 return {};
             },
         };
@@ -53,7 +53,7 @@ export async function runManualTrigger(configPath, profileId, input, output = wr
         }));
         const record = (await store.list()).find((candidate) => candidate.triggerKey === claim.record.triggerKey);
         if (record?.run?.state !== "succeeded" ||
-            (record.finalOutcome?.content.kind !== "no_reply" &&
+            (record.finalOutcome?.content.reply.kind !== "no_reply" &&
                 record.delivery?.state !== "delivered")) {
             throw new Error(`Manual Trigger failed: ${record?.run?.failure?.code ?? record?.delivery?.failure?.code ?? "unknown"}`);
         }

package/dist/outcome/content.js

@@ -10,30 +10,106 @@ const buttonSchema = z
         .refine((value) => value.startsWith("https://") || value.startsWith("http://"), "must use http or https"),
 })
     .strict();
-export const finalOutcomeContentSchema = z.discriminatedUnion("kind", [
-    z.object({ kind: z.literal("text"), text: nonBlank }).strict(),
-    z.object({ kind: z.literal("no_reply"), reason: nonBlank }).strict(),
-    z
-        .object({
-        kind: z.literal("card"),
-        title: nonBlank,
-        content: nonBlank,
-        buttons: z.array(buttonSchema).max(5).default([]),
-    })
-        .strict(),
+const textReplySchema = z
+    .object({ kind: z.literal("text"), text: nonBlank })
+    .strict();
+const noReplySchema = z
+    .object({ kind: z.literal("no_reply"), reason: nonBlank })
+    .strict();
+const replySchema = z.discriminatedUnion("kind", [
+    textReplySchema,
+    noReplySchema,
+]);
+const cardSchema = z
+    .object({
+    kind: z.literal("card"),
+    title: nonBlank,
+    content: nonBlank,
+    buttons: z.array(buttonSchema).max(5).default([]),
+})
+    .strict();
+export const finalOutcomeContentSchema = z
+    .object({
+    reply: replySchema,
+    notify: cardSchema.optional(),
+})
+    .strict();
+const outcomePatchSchema = z
+    .object({
+    reply: replySchema.optional(),
+    notify: cardSchema.optional(),
+})
+    .strict()
+    .refine((value) => value.reply !== undefined || value.notify !== undefined, {
+    message: "Outcome submission must include reply or notify",
+});
+const legacyOutcomeSchema = z.discriminatedUnion("kind", [
+    textReplySchema,
+    noReplySchema,
+    cardSchema,
 ]);
+function renderCard(card) {
+    return [
+        `# ${card.title}`,
+        "",
+        card.content,
+        ...card.buttons.map((button) => `\n[${button.label}](${button.url})`),
+    ].join("\n");
+}
 export function parseFinalOutcomeContent(value) {
+    const legacy = legacyOutcomeSchema.safeParse(value);
+    if (legacy.success) {
+        if (legacy.data.kind === "card") {
+            return {
+                reply: { kind: "text", text: renderCard(legacy.data) },
+                notify: legacy.data,
+            };
+        }
+        return { reply: legacy.data };
+    }
     return finalOutcomeContentSchema.parse(value);
 }
+export function parseOutcomePatch(value) {
+    const legacy = legacyOutcomeSchema.safeParse(value);
+    if (legacy.success)
+        return parseFinalOutcomeContent(legacy.data);
+    return outcomePatchSchema.parse(value);
+}
+export function mergeOutcome(current, patch) {
+    if (patch.reply && current?.reply) {
+        throw new Error("Reply already submitted");
+    }
+    if (patch.notify && current?.notify) {
+        throw new Error("Notify already submitted");
+    }
+    return {
+        ...(current?.reply || patch.reply
+            ? { reply: patch.reply ?? current?.reply }
+            : {}),
+        ...(current?.notify || patch.notify
+            ? { notify: patch.notify ?? current?.notify }
+            : {}),
+    };
+}
+export function completeOutcome(partial) {
+    if (!partial.reply) {
+        throw new Error("Agent Runtime settled without submitting reply or no_reply");
+    }
+    return {
+        reply: partial.reply,
+        ...(partial.notify ? { notify: partial.notify } : {}),
+    };
+}
 export function renderFinalOutcomeAsText(outcome) {
-    if (outcome.kind === "text")
-        return outcome.text;
-    if (outcome.kind === "no_reply")
-        return "";
-    return [
-        `# ${outcome.title}`,
-        "",
-        outcome.content,
-        ...outcome.buttons.map((button) => `\n[${button.label}](${button.url})`),
-    ].join("\n");
+    const parts = [];
+    if (outcome.reply.kind === "text")
+        parts.push(outcome.reply.text);
+    if (outcome.notify)
+        parts.push(renderCard(outcome.notify));
+    return parts.join("\n\n");
+}
+export function renderDeliveryAsText(content) {
+    if (content.kind === "text")
+        return content.text;
+    return renderCard(content);
 }

package/dist/outcome/doctor.js

@@ -18,7 +18,8 @@ export async function runOutcomeDoctor(profileId) {
     const beaconCliPath = fileURLToPath(new URL("../../dist/cli.js", import.meta.url));
     try {
         const result = await createProfileRunner(profile, outcomes, beaconCliPath)(doctorTrigger);
-        if (result.kind !== "text" || result.text.trim() !== "OUTCOME_CLI_OK") {
+        if (result.reply.kind !== "text" ||
+            result.reply.text.trim() !== "OUTCOME_CLI_OK") {
             throw new Error(`Outcome doctor received unexpected submitted text: ${JSON.stringify(result)}`);
         }
         console.log("[beacon] explicit Final Outcome chain ready");

package/dist/outcome/instructions.js

@@ -1,5 +1,8 @@
+export const inboundOutOfRoleReply = "这条消息不在我的职责范围内。";
 export const finalOutcomeSystemInstructions = [
-    "When your work is complete, call exactly one of submit_final_outcome_text, submit_final_outcome_card, or submit_final_outcome_no_reply.",
-    "Use submit_final_outcome_text for a normal response, submit_final_outcome_card when a titled Markdown summary and link buttons materially improve the result, or submit_final_outcome_no_reply when the triggering message is outside the Profile's role and should receive no response.",
+    "When your work is complete, close the conversational channel with exactly one of `reply` or `no_reply`. You may also call `notify_card` at most once on the same Run.",
+    "`reply` sends plain text. For an inbound Feishu message, quote-reply that message. For a Schedule, message the Profile admin. Inbound Runs must call `reply`, even when the message is outside this Profile's role: send a short text saying the request is out of scope. Do not call `no_reply` on inbound messages.",
+    "`no_reply` finishes a Schedule without messaging the admin. Its reason is stored for audit and is never sent. Do not use it for inbound Feishu messages.",
+    "`notify_card` posts a titled Markdown card to the Schedule's configured group. Call it only when this Run is a Schedule with a notify target. Inbound messages cannot notify.",
     "Beacon ignores ordinary assistant final text for Delivery.",
 ];

package/dist/outcome/server.js

@@ -3,7 +3,7 @@ import { mkdtemp, rm } from "node:fs/promises";
 import { createServer } from "node:net";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { parseFinalOutcomeContent } from "./content.js";
+import { completeOutcome, mergeOutcome, parseOutcomePatch, } from "./content.js";
 function respond(socket, response) {
     socket.end(`${JSON.stringify(response)}\n`);
 }
@@ -54,9 +54,9 @@ export async function startOutcomeServer(options = {}) {
                 });
                 return;
             }
-            let outcome;
+            let patch;
             try {
-                outcome = parseFinalOutcomeContent(request.outcome);
+                patch = parseOutcomePatch(request.outcome);
             }
             catch (error) {
                 respond(socket, {
@@ -70,14 +70,16 @@ export async function startOutcomeServer(options = {}) {
                 respond(socket, { ok: false, error: "unknown Run Capability" });
                 return;
             }
-            if (submission.outcome !== undefined) {
+            try {
+                submission.outcome = mergeOutcome(submission.outcome, patch);
+            }
+            catch (error) {
                 respond(socket, {
                     ok: false,
-                    error: "Final Outcome already submitted",
+                    error: error instanceof Error ? error.message : String(error),
                 });
                 return;
             }
-            submission.outcome = outcome;
             console.log("[beacon] Final Outcome submitted by Agent Runtime");
             respond(socket, { ok: true });
         });
@@ -98,10 +100,7 @@ export async function startOutcomeServer(options = {}) {
                 binding: { socketPath, runToken },
                 take() {
                     submissions.delete(runToken);
-                    if (record.outcome === undefined) {
-                        throw new Error("Agent Runtime settled without submitting a Final Outcome");
-                    }
-                    return record.outcome;
+                    return completeOutcome(record.outcome ?? {});
                 },
                 cancel() {
                     submissions.delete(runToken);

package/dist/outcome/submit.js

@@ -1,13 +1,13 @@
 import { createConnection } from "node:net";
-import { parseFinalOutcomeContent } from "./content.js";
+import { completeOutcome, mergeOutcome, parseOutcomePatch, } from "./content.js";
 export async function submitOutcome(socketPath, runToken, outcome) {
-    const validatedOutcome = parseFinalOutcomeContent(outcome);
+    const patch = parseOutcomePatch(outcome);
     await new Promise((resolve, reject) => {
         const socket = createConnection(socketPath);
         socket.setEncoding("utf8");
         let responseBuffer = "";
         socket.once("connect", () => {
-            socket.write(`${JSON.stringify({ runToken, outcome: validatedOutcome })}\n`);
+            socket.write(`${JSON.stringify({ runToken, outcome: patch })}\n`);
         });
         socket.on("data", (chunk) => {
             responseBuffer += chunk;
@@ -42,15 +42,16 @@ export async function submitOutcomeFromCli() {
     let input = "";
     for await (const chunk of process.stdin)
         input += chunk;
-    let outcome;
+    let patch;
     try {
-        outcome = parseFinalOutcomeContent(JSON.parse(input));
+        patch = parseOutcomePatch(JSON.parse(input));
     }
     catch (error) {
         throw new Error("Final Outcome stdin must be valid outcome JSON", {
             cause: error,
         });
     }
-    await submitOutcome(socketPath, runToken, outcome);
+    await submitOutcome(socketPath, runToken, patch);
     console.log("Final Outcome accepted by Beacon");
 }
+export { completeOutcome, mergeOutcome };

package/dist/run/orchestrator.js

@@ -1,5 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { isAbsolute, join } from "node:path";
+import { inboundOutOfRoleReply } from "../outcome/instructions.js";
 import { PiRuntimeError } from "../runtime/pi-rpc.js";
 import { buildAgentSystemPrompt } from "../runtime/system-prompt.js";
 function promptFor(input) {
@@ -38,6 +39,26 @@ function summary(error) {
     const value = error instanceof Error ? error.message : String(error);
     return value.slice(0, 4096) || "unknown failure";
 }
+function failureOutcome(runId) {
+    return {
+        reply: {
+            kind: "text",
+            text: `处理失败（run_id=${runId}），请查看 Beacon 本地记录。`,
+        },
+    };
+}
+function normalizeAgentOutcome(input, outcome, notifyTarget) {
+    if (input.kind !== "schedule" && outcome.notify) {
+        throw new Error("notify_card is only valid on Schedule Runs");
+    }
+    if (outcome.notify && !notifyTarget) {
+        throw new Error("notify_card requires a configured notify chat");
+    }
+    if (input.kind === "feishu_message" && outcome.reply.kind === "no_reply") {
+        return { reply: { kind: "text", text: inboundOutOfRoleReply } };
+    }
+    return outcome;
+}
 export class RunOrchestrator {
     options;
     now;
@@ -53,6 +74,12 @@ export class RunOrchestrator {
     timestamp() {
         return this.now().toISOString();
     }
+    async record(triggerKey) {
+        const found = (await this.options.store.list()).find((candidate) => candidate.triggerKey === triggerKey);
+        if (!found)
+            throw new Error(`Unknown Trigger ${triggerKey}`);
+        return found;
+    }
     newRun(runId, state, failure) {
         const timestamp = this.timestamp();
         return {
@@ -71,39 +98,39 @@ export class RunOrchestrator {
             ...(failure ? { failure } : {}),
         };
     }
-    async deliver(triggerKey, create = true) {
+    async deliverField(triggerKey, field, target, content, create = true) {
         const deliveryId = `del_${this.id()}`;
-        let record;
         if (create) {
-            record = await this.options.store.update(triggerKey, (current) => ({
+            await this.options.store.update(triggerKey, (current) => ({
                 ...current,
-                delivery: {
+                [field]: {
                     deliveryId,
-                    target: current.target,
+                    target,
                     state: "pending",
                 },
             }));
         }
         else {
-            record = (await this.options.store.list()).find((candidate) => candidate.triggerKey === triggerKey);
-            if (record.delivery?.state !== "pending") {
-                throw new Error(`Cannot resume non-pending Delivery for Trigger ${triggerKey}`);
+            const current = await this.record(triggerKey);
+            if (current[field]?.state !== "pending") {
+                return;
             }
         }
-        record = await this.options.store.update(triggerKey, (current) => ({
+        await this.options.store.update(triggerKey, (current) => ({
             ...current,
-            delivery: {
-                ...current.delivery,
+            [field]: {
+                ...current[field],
                 state: "delivering",
                 startedAt: this.timestamp(),
             },
         }));
+        const live = await this.record(triggerKey);
         try {
-            const result = await this.options.delivery.deliver(record.target, record.finalOutcome.content, record.delivery.deliveryId);
+            const result = await this.options.delivery.deliver(target, content, live[field].deliveryId);
             await this.options.store.update(triggerKey, (current) => ({
                 ...current,
-                delivery: {
-                    ...current.delivery,
+                [field]: {
+                    ...current[field],
                     state: "delivered",
                     finishedAt: this.timestamp(),
                     ...(result.providerRequestId
@@ -115,8 +142,8 @@ export class RunOrchestrator {
         catch (error) {
             await this.options.store.update(triggerKey, (current) => ({
                 ...current,
-                delivery: {
-                    ...current.delivery,
+                [field]: {
+                    ...current[field],
                     state: "failed",
                     finishedAt: this.timestamp(),
                     failure: { code: "delivery_api_failed", summary: summary(error) },
@@ -124,6 +151,16 @@ export class RunOrchestrator {
             }));
         }
     }
+    async deliverOutcome(triggerKey, create = true) {
+        const current = await this.record(triggerKey);
+        const outcome = current.finalOutcome.content;
+        if (outcome.reply.kind === "text") {
+            await this.deliverField(triggerKey, "delivery", current.target, outcome.reply, create && current.delivery === undefined);
+        }
+        if (outcome.notify && current.notifyTarget) {
+            await this.deliverField(triggerKey, "notifyDelivery", current.notifyTarget, outcome.notify, create && current.notifyDelivery === undefined);
+        }
+    }
     async fail(triggerKey, runId, code, error) {
         const detail = summary(error);
         await this.options.store.update(triggerKey, (current) => ({
@@ -136,14 +173,11 @@ export class RunOrchestrator {
             },
             finalOutcome: {
                 origin: "beacon_failure",
-                content: {
-                    kind: "text",
-                    text: `处理失败（run_id=${runId}），请查看 Beacon 本地记录。`,
-                },
+                content: failureOutcome(runId),
                 submittedAt: this.timestamp(),
             },
         }));
-        await this.deliver(triggerKey);
+        await this.deliverOutcome(triggerKey);
     }
     async execute(triggerKey, input, runId) {
         const record = await this.options.store.update(triggerKey, (current) => {
@@ -156,7 +190,6 @@ export class RunOrchestrator {
                     sessionPath: current.run.sessionPath,
                 }
                 : {
-                    // Migration for queued records written by Beacon <= 0.1.2.
                     sessionId: current.run.runId,
                     sessionPath: join(this.options.sessionDirectory, this.options.profile.id, current.run.runId),
                 };
@@ -189,7 +222,7 @@ export class RunOrchestrator {
                     name: `Beacon ${this.options.profile.id} ${runId}`,
                 },
             });
-            const outcome = submission.take();
+            const outcome = normalizeAgentOutcome(input, submission.take(), record.notifyTarget);
             await this.options.store.update(triggerKey, (current) => ({
                 ...current,
                 run: {
@@ -205,15 +238,14 @@ export class RunOrchestrator {
                     submittedAt: this.timestamp(),
                 },
             }));
-            if (outcome.kind !== "no_reply")
-                await this.deliver(triggerKey);
+            await this.deliverOutcome(triggerKey);
         }
         catch (error) {
             submission.cancel();
             const code = error instanceof PiRuntimeError
                 ? error.code
                 : error instanceof Error &&
-                    /submitting a Final Outcome/.test(error.message)
+                    /submitting a (Final Outcome|reply or no_reply)/.test(error.message)
                     ? "outcome_missing"
                     : "runtime_exit_failed";
             await this.fail(triggerKey, runId, code, error);
@@ -234,14 +266,11 @@ export class RunOrchestrator {
                 }),
                 finalOutcome: {
                     origin: "beacon_failure",
-                    content: {
-                        kind: "text",
-                        text: `处理失败（run_id=${runId}），请查看 Beacon 本地记录。`,
-                    },
+                    content: failureOutcome(runId),
                     submittedAt: this.timestamp(),
                 },
             }));
-            await this.deliver(triggerKey);
+            await this.deliverOutcome(triggerKey);
             return;
         }
         await this.options.store.update(triggerKey, (current) => ({
@@ -258,46 +287,54 @@ export class RunOrchestrator {
     }
     async recover() {
         for (const record of await this.options.store.list()) {
-            if (record.delivery?.state === "delivering") {
-                await this.options.store.update(record.triggerKey, (current) => ({
-                    ...current,
-                    delivery: {
-                        ...current.delivery,
-                        state: "failed",
-                        finishedAt: this.timestamp(),
-                        failure: {
-                            code: "delivery_interrupted",
-                            summary: "Service restarted while Delivery result was unknown",
+            for (const field of ["delivery", "notifyDelivery"]) {
+                if (record[field]?.state === "delivering") {
+                    await this.options.store.update(record.triggerKey, (current) => ({
+                        ...current,
+                        [field]: {
+                            ...current[field],
+                            state: "failed",
+                            finishedAt: this.timestamp(),
+                            failure: {
+                                code: "delivery_interrupted",
+                                summary: "Service restarted while Delivery result was unknown",
+                            },
                         },
-                    },
-                }));
-                continue;
+                    }));
+                }
             }
-            if (record.delivery?.state === "pending") {
-                await this.deliver(record.triggerKey, false);
+            const latest = await this.record(record.triggerKey);
+            if (latest.delivery?.state === "pending" ||
+                latest.notifyDelivery?.state === "pending") {
+                await this.deliverOutcome(latest.triggerKey, false);
                 continue;
             }
-            if (record.run?.state === "starting" || record.run?.state === "running") {
-                await this.fail(record.triggerKey, record.run.runId, "service_interrupted", "Service restarted while Run was active");
+            if (latest.run?.state === "starting" || latest.run?.state === "running") {
+                await this.fail(latest.triggerKey, latest.run.runId, "service_interrupted", "Service restarted while Run was active");
                 continue;
             }
-            if (record.run?.state === "queued" && record.input) {
-                const queued = this.options.queue.enqueue(() => this.execute(record.triggerKey, record.input, record.run.runId));
+            if (latest.run?.state === "queued" && latest.input) {
+                const queued = this.options.queue.enqueue(() => this.execute(latest.triggerKey, latest.input, latest.run.runId));
                 if (!queued.accepted) {
                     throw new Error("Persisted queued Runs exceed configured queue capacity");
                 }
                 await queued.completion;
                 continue;
             }
-            if (!record.run) {
-                await this.fail(record.triggerKey, `run_${this.id()}`, "service_interrupted", "Service restarted before Trigger normalization completed");
+            if (!latest.run) {
+                await this.fail(latest.triggerKey, `run_${this.id()}`, "service_interrupted", "Service restarted before Trigger normalization completed");
                 continue;
             }
-            if (record.finalOutcome &&
-                record.finalOutcome.content.kind !== "no_reply" &&
-                !record.delivery &&
-                (record.run.state === "succeeded" || record.run.state === "failed")) {
-                await this.deliver(record.triggerKey);
+            if (latest.finalOutcome &&
+                (latest.run.state === "succeeded" || latest.run.state === "failed")) {
+                const outcome = latest.finalOutcome.content;
+                const missingReply = outcome.reply.kind === "text" && !latest.delivery;
+                const missingNotify = Boolean(outcome.notify) &&
+                    Boolean(latest.notifyTarget) &&
+                    !latest.notifyDelivery;
+                if (missingReply || missingNotify) {
+                    await this.deliverOutcome(latest.triggerKey);
+                }
             }
         }
     }

package/dist/runtime/pi-outcome-extension.js

@@ -1,18 +1,27 @@
 import { spawn } from "node:child_process";
-import { parseFinalOutcomeContent } from "../outcome/content.js";
-export function textOutcomeFromToolParams(params) {
-    return parseFinalOutcomeContent({ kind: "text", text: params.text });
+import { parseOutcomePatch } from "../outcome/content.js";
+export function replyFromToolParams(params) {
+    return parseOutcomePatch({
+        reply: { kind: "text", text: params.text },
+    });
 }
-export function cardOutcomeFromToolParams(params) {
-    return parseFinalOutcomeContent({
-        kind: "card",
-        title: params.title,
-        content: params.content,
-        buttons: params.buttons ?? [],
+export function noReplyFromToolParams(params) {
+    return parseOutcomePatch({
+        reply: { kind: "no_reply", reason: params.reason },
     });
 }
-export function noReplyOutcomeFromToolParams(params) {
-    return parseFinalOutcomeContent({ kind: "no_reply", reason: params.reason });
+export function notifyCardFromToolParams(params) {
+    const patch = parseOutcomePatch({
+        notify: {
+            kind: "card",
+            title: params.title,
+            content: params.content,
+            buttons: params.buttons ?? [],
+        },
+    });
+    if (!patch.notify)
+        throw new Error("notify_card produced no card");
+    return patch.notify;
 }
 async function invokeBeaconCli(outcome, signal) {
     const cliPath = process.env.BEACON_CLI_PATH;
@@ -48,9 +57,9 @@ function acceptedResult() {
 }
 export default function registerOutcomeTools(pi) {
     pi.registerTool({
-        name: "submit_final_outcome_text",
-        label: "Submit Final Outcome Text",
-        description: "Submit the final response as a normal text message. Call exactly one Final Outcome tool after completing the task.",
+        name: "reply",
+        label: "Reply",
+        description: "Send a plain-text reply. Inbound Feishu messages quote-reply the user. Schedules message the admin. Inbound Runs must use this tool, including out-of-role messages.",
         parameters: {
             type: "object",
             properties: {
@@ -64,14 +73,35 @@ export default function registerOutcomeTools(pi) {
             additionalProperties: false,
         },
         async execute(_toolCallId, params, signal) {
-            await invokeBeaconCli(textOutcomeFromToolParams(params), signal);
+            await invokeBeaconCli({ reply: { kind: "text", text: params.text } }, signal);
+            return acceptedResult();
+        },
+    });
+    pi.registerTool({
+        name: "no_reply",
+        label: "No Reply",
+        description: "Finish a Schedule without messaging the admin. Do not use this on inbound Feishu messages.",
+        parameters: {
+            type: "object",
+            properties: {
+                reason: {
+                    type: "string",
+                    minLength: 1,
+                    description: "A concise internal reason why the admin should not be messaged.",
+                },
+            },
+            required: ["reason"],
+            additionalProperties: false,
+        },
+        async execute(_toolCallId, params, signal) {
+            await invokeBeaconCli({ reply: { kind: "no_reply", reason: params.reason } }, signal);
             return acceptedResult();
         },
     });
     pi.registerTool({
-        name: "submit_final_outcome_card",
-        label: "Submit Final Outcome Card",
-        description: "Submit the final response as a structured Feishu card. Call exactly one Final Outcome tool after completing the task.",
+        name: "notify_card",
+        label: "Notify Card",
+        description: "Post a structured Feishu card to the Schedule's configured notify group. Inbound messages cannot notify. You must still call reply or no_reply on the same Run.",
         parameters: {
             type: "object",
             properties: {
@@ -103,28 +133,14 @@ export default function registerOutcomeTools(pi) {
             additionalProperties: false,
         },
         async execute(_toolCallId, params, signal) {
-            await invokeBeaconCli(cardOutcomeFromToolParams(params), signal);
-            return acceptedResult();
-        },
-    });
-    pi.registerTool({
-        name: "submit_final_outcome_no_reply",
-        label: "Submit No Reply Outcome",
-        description: "Complete the run without sending a reply. Use this exactly once when the triggering message is outside the Profile's role.",
-        parameters: {
-            type: "object",
-            properties: {
-                reason: {
-                    type: "string",
-                    minLength: 1,
-                    description: "A concise internal reason why the message should not receive a reply.",
+            await invokeBeaconCli({
+                notify: {
+                    kind: "card",
+                    title: params.title,
+                    content: params.content,
+                    buttons: params.buttons ?? [],
                 },
-            },
-            required: ["reason"],
-            additionalProperties: false,
-        },
-        async execute(_toolCallId, params, signal) {
-            await invokeBeaconCli(noReplyOutcomeFromToolParams(params), signal);
+            }, signal);
             return acceptedResult();
         },
     });

package/dist/schedule/reconciler.js

@@ -1,3 +1,4 @@
+import { profileAdminChatId } from "../config/profile.js";
 import { occurrencesBetween } from "./cron.js";
 export class ScheduleReconciler {
     options;
@@ -18,7 +19,13 @@ export class ScheduleReconciler {
             const scheduledFor = latest.toISOString();
             const claim = await this.options.triggers.claim({
                 sourceKey: ["schedule", schedule.id, scheduledFor],
-                target: { kind: "chat", chatId: schedule.delivery.chatId },
+                target: {
+                    kind: "chat",
+                    chatId: profileAdminChatId(this.options.profile),
+                },
+                ...(schedule.notify
+                    ? { notifyTarget: { kind: "chat", chatId: schedule.notify.chatId } }
+                    : {}),
                 ingress: {
                     scheduleId: schedule.id,
                     scheduledFor,

package/dist/schedule-trigger.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { loadGlobalConfig } from "./config/global.js";
+import { profileAdminChatId } from "./config/profile.js";
 import { loadProfileRegistry } from "./config/registry.js";
 import { loadRuntimeEnvironment } from "./config/runtime-environment.js";
 import { loadFeishuCredentials } from "./config/secrets.js";
@@ -21,7 +22,10 @@ export async function triggerScheduleOnce(options) {
     const invocationId = (options.id ?? randomUUID)();
     const claim = await options.store.claim({
         sourceKey: ["manual-schedule", schedule.id, invocationId],
-        target: { kind: "chat", chatId: schedule.delivery.chatId },
+        target: { kind: "chat", chatId: profileAdminChatId(options.profile) },
+        ...(schedule.notify
+            ? { notifyTarget: { kind: "chat", chatId: schedule.notify.chatId } }
+            : {}),
         ingress: {
             invocation: "manual",
             scheduleId: schedule.id,

package/dist/state/trigger-store.js

@@ -3,7 +3,7 @@ import { chmod, mkdir, open, readdir, readFile, rename, } from "node:fs/promises
 import { basename, dirname, isAbsolute, join } from "node:path";
 import { z } from "zod";
 import { failureCodes, } from "../domain/types.js";
-import { finalOutcomeContentSchema } from "../outcome/content.js";
+import { finalOutcomeContentSchema, parseFinalOutcomeContent, } from "../outcome/content.js";
 const timestamp = z.string().datetime({ offset: true });
 const failureSchema = z
     .object({ code: z.enum(failureCodes), summary: z.string().min(1).max(4096) })
@@ -69,7 +69,14 @@ const outcomeSchema = z.union([
     z
         .object({
         origin: z.enum(["agent", "beacon_failure"]),
-        content: finalOutcomeContentSchema,
+        content: z.preprocess((value) => {
+            try {
+                return parseFinalOutcomeContent(value);
+            }
+            catch {
+                return value;
+            }
+        }, finalOutcomeContentSchema),
         submittedAt: timestamp,
     })
         .strict(),
@@ -82,7 +89,7 @@ const outcomeSchema = z.union([
         .strict()
         .transform(({ origin, text, submittedAt }) => ({
         origin,
-        content: { kind: "text", text },
+        content: { reply: { kind: "text", text } },
         submittedAt,
     })),
 ]);
@@ -106,11 +113,13 @@ const triggerRecordSchema = z
     sourceKey: z.array(z.string().min(1)).min(2),
     acceptedAt: timestamp,
     target: targetSchema,
+    notifyTarget: targetSchema.optional(),
     input: inputSchema.optional(),
     ingress: z.record(z.string(), z.unknown()).optional(),
     run: runSchema.optional(),
     finalOutcome: outcomeSchema.optional(),
     delivery: deliverySchema.optional(),
+    notifyDelivery: deliverySchema.optional(),
 })
     .strict();
 function keyFor(profileId, sourceKey) {
@@ -134,6 +143,19 @@ function validateRecord(value) {
     if (record.delivery && !record.finalOutcome) {
         throw new Error("Trigger record with Delivery must contain a Final Outcome");
     }
+    if (record.notifyDelivery && !record.finalOutcome) {
+        throw new Error("Trigger record with notify Delivery must contain a Final Outcome");
+    }
+    if (record.delivery &&
+        record.finalOutcome?.content.reply.kind === "no_reply") {
+        throw new Error("no_reply Outcomes must not have a reply Delivery");
+    }
+    if (record.notifyDelivery && !record.finalOutcome?.content.notify) {
+        throw new Error("notify Delivery requires a notify card");
+    }
+    if (record.notifyDelivery && !record.notifyTarget) {
+        throw new Error("notify Delivery requires a notify target");
+    }
     if (record.run?.state === "succeeded" &&
         record.finalOutcome?.origin !== "agent") {
         throw new Error("Succeeded Run must contain an Agent Final Outcome");
@@ -243,6 +265,7 @@ export class TriggerStore {
             sourceKey: [...request.sourceKey],
             acceptedAt: (request.acceptedAt ?? new Date()).toISOString(),
             target: request.target,
+            ...(request.notifyTarget ? { notifyTarget: request.notifyTarget } : {}),
             ...(request.ingress ? { ingress: request.ingress } : {}),
         };
         await this.write(triggerKey, record);

package/examples/profiles/example/profile.yaml

@@ -4,10 +4,12 @@ runtime: pi
 model:
   provider: REPLACE_WITH_PI_PROVIDER
   id: REPLACE_WITH_PI_MODEL
+admin:
+  chat_id: REPLACE_WITH_ADMIN_DIRECT_CHAT_ID
 schedules:
   - id: weekday-brief
     cron: "0 9 * * 1-5"
     timezone: Asia/Shanghai
     input: Prepare the weekday brief.
-    delivery:
-      chat_id: REPLACE_WITH_DIRECT_OR_GROUP_CHAT_ID
+    notify:
+      chat_id: REPLACE_WITH_GROUP_CHAT_ID

package/examples/profiles/example/prompt.md

@@ -2,6 +2,8 @@ You are a workspace-status assistant. Your only role is to answer requests about
 
 Before reading files or running commands, decide whether the input is within that role. A group `@ All` does not by itself address this bot, and a direct message is not automatically relevant. Use the quoted-message chain when the current message is a follow-up.
 
-If the input is outside this role, immediately call `submit_final_outcome_no_reply` with a concise internal reason. Do not inspect the workspace or submit a text or card response.
+If a Feishu message is outside this role, call `reply` with a short text saying the request is out of scope. Do not inspect the workspace. Do not call `no_reply` on inbound messages.
 
-For relevant input, work only within the configured workspace and return a concise, user-facing result through the appropriate Final Outcome tool. Required operations must fail visibly; do not fabricate fallback data or report success after incomplete work.
+Scheduled Runs that have nothing to report should call `no_reply`. If a Schedule has a notify group and there is a report for that group, call `notify_card` and then `no_reply` unless the admin also needs a text update.
+
+For in-role work, stay inside the configured workspace and call `reply` with a concise user-facing result. Required operations must fail visibly; do not fabricate fallback data or report success after incomplete work.

package/package.json

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