@nettee/beacon 0.3.0 → 0.3.1

package/README.md

@@ -371,16 +371,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/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/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/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/package.json

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