@nettee/beacon 0.3.5 → 0.4.0

package/dist/daemon/feishu/final-outcome-card.d.ts

@@ -0,0 +1,20 @@
+import type { CardContent } from "../domain/types.js";
+type CardOutcome = CardContent;
+export type FeishuFinalOutcomeCard = {
+    config: {
+        wide_screen_mode: true;
+    };
+    header: {
+        template: "blue";
+        title: {
+            tag: "plain_text";
+            content: string;
+        };
+    };
+    elements: object[];
+};
+export declare function buildFeishuFinalOutcomeCard(outcome: CardOutcome, options?: {
+    generatedAt?: Date;
+    timeZone?: string;
+}): FeishuFinalOutcomeCard;
+export {};

package/dist/daemon/feishu/gateway.d.ts

@@ -0,0 +1,46 @@
+import type { FeishuCredentials } from "../config/secrets.js";
+import type { DeliveryContent } from "../domain/types.js";
+import type { DeliveryAdapter } from "../run/orchestrator.js";
+import type { FeishuMessageEvent } from "./intake.js";
+import type { FeishuMessageGateway } from "./message-gateway.js";
+import type { FetchedMessage } from "./trigger-input.js";
+type ApiResult = {
+    code?: number | undefined;
+    msg?: string | undefined;
+    request_id?: string | undefined;
+};
+type MessageSendResult = ApiResult & {
+    data?: {
+        message_id?: string | undefined;
+    } | undefined;
+};
+/** Prefer Feishu's outbound `message_id` so quote-replies can resume that Run's Pi session. */
+export declare function providerRequestIdFromMessageSend(result: MessageSendResult): {
+    providerRequestId?: string | undefined;
+};
+type ShutdownSignalSource = {
+    once(event: "SIGINT" | "SIGTERM", listener: () => void): unknown;
+    off(event: "SIGINT" | "SIGTERM", listener: () => void): unknown;
+};
+export declare function waitForShutdown(signals?: ShutdownSignalSource): Promise<void>;
+export declare function shouldAcceptFeishuMessage(chatType: string, senderType: string, messageId: string, processedMessageIds: ReadonlySet<string>): boolean;
+export declare function encodeFeishuFinalOutcome(outcome: DeliveryContent): {
+    msgType: "text" | "interactive";
+    content: string;
+};
+export declare class FeishuGateway implements FeishuMessageGateway {
+    private readonly credentials;
+    private readonly client;
+    constructor(credentials: FeishuCredentials);
+    checkReady(): Promise<void>;
+    run(handleEvent: (event: FeishuMessageEvent) => Promise<unknown>, shutdown?: Promise<void>): Promise<void>;
+    acknowledge(messageId: string): Promise<{
+        clear: () => Promise<void>;
+    }>;
+    fetchMessage(messageId: string): Promise<FetchedMessage>;
+    deliver(target: Parameters<DeliveryAdapter["deliver"]>[0], outcome: Parameters<DeliveryAdapter["deliver"]>[1]): Promise<{
+        providerRequestId?: string | undefined;
+    }>;
+}
+export declare function createFeishuGateway(credentials: FeishuCredentials): FeishuGateway;
+export {};

package/dist/daemon/feishu/intake.d.ts

@@ -0,0 +1,37 @@
+import type { TriggerInput } from "../domain/types.js";
+import type { Acknowledgement } from "../message/gateway.js";
+import type { TriggerStore } from "../state/trigger-store.js";
+import { type FeishuMention } from "./mentions.js";
+import { type FetchedMessage } from "./trigger-input.js";
+export type FeishuMessageEvent = {
+    event_id?: string | undefined;
+    sender: {
+        sender_type: string;
+        sender_id?: {
+            open_id?: string | undefined;
+        } | undefined;
+    };
+    message: {
+        message_id: string;
+        chat_id: string;
+        chat_type: string;
+        message_type: string;
+        content: string;
+        parent_id?: string | undefined;
+        mentions?: FeishuMention[] | undefined;
+    };
+};
+export type FeishuIntakeOptions = {
+    store: TriggerStore;
+    process(triggerKey: string, normalize: () => Promise<TriggerInput>): Promise<void>;
+    fetchMessage(messageId: string): Promise<FetchedMessage>;
+    acknowledge(messageId: string): Promise<Acknowledgement>;
+    onFatal(error: Error): void;
+};
+export declare class FeishuIntake {
+    private readonly options;
+    private readonly active;
+    constructor(options: FeishuIntakeOptions);
+    handle(event: FeishuMessageEvent): Promise<"accepted" | "duplicate" | "ignored">;
+    drain(): Promise<void>;
+}

package/dist/daemon/feishu/mentions.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Temporary hard cut: group @All must not start a Beacon run.
+ * Prefer Feishu `message.mentions`; fall back to content placeholders.
+ */
+export type FeishuMention = {
+    key?: string | undefined;
+    id?: {
+        open_id?: string | undefined;
+        user_id?: string | undefined;
+        union_id?: string | undefined;
+    } | undefined;
+    name?: string | undefined;
+    mentioned_type?: string | undefined;
+};
+export type FeishuMentionDecisionInput = {
+    chatType: string;
+    mentions?: FeishuMention[] | undefined;
+    messageType?: string | undefined;
+    content?: string | undefined;
+};
+/** True when a Feishu mention entry is @All / @所有人 / @_all. */
+export declare function isFeishuAtAllMention(mention: FeishuMention): boolean;
+/** Detect @_all / at-all markers inside raw Feishu message content JSON. */
+export declare function contentIndicatesFeishuAtAll(content: string | undefined): boolean;
+/**
+ * A direct bot (or other entity) @mention — anything in `mentions` that is not @All.
+ * With mention-only Feishu scopes, non-@All mentions are the bot itself.
+ */
+export declare function hasDirectFeishuMention(mentions: readonly FeishuMention[] | undefined): boolean;
+/**
+ * Beacon-layer gate for inbound Feishu events.
+ * - DM (p2p): always process
+ * - Group: process only when a non-@All mention is present
+ * - Pure @All (with or without @_all content): ignore
+ * - @All + @bot together: process (direct mention wins)
+ */
+export declare function shouldProcessFeishuInbound(input: FeishuMentionDecisionInput): boolean;

package/dist/daemon/feishu/message-gateway.d.ts

@@ -0,0 +1,4 @@
+import type { MessageGateway } from "../message/gateway.js";
+import type { FeishuMessageEvent } from "./intake.js";
+import type { FetchedMessage } from "./trigger-input.js";
+export type FeishuMessageGateway = MessageGateway<FeishuMessageEvent, FetchedMessage>;

package/dist/daemon/feishu/message-pipeline.d.ts

@@ -0,0 +1,13 @@
+import type { TriggerInput } from "../domain/types.js";
+import type { TriggerStore } from "../state/trigger-store.js";
+import type { FeishuMessageGateway } from "./message-gateway.js";
+export type FeishuMessagePipelineOptions = {
+    gateway: FeishuMessageGateway;
+    store: TriggerStore;
+    process(triggerKey: string, normalize: () => Promise<TriggerInput>): Promise<void>;
+    onFatal(error: Error): void;
+};
+export declare function createFeishuMessagePipeline(options: FeishuMessagePipelineOptions): {
+    run: (shutdown: Promise<void>) => Promise<void>;
+    drain: () => Promise<void>;
+};

package/dist/daemon/feishu/reply-experiment.d.ts

@@ -0,0 +1,3 @@
+import type { FeishuCredentials } from "../config/secrets.js";
+export declare function shouldExerciseReplyExperiment(chatType: string, messageId: string, processedMessageIds: ReadonlySet<string>): boolean;
+export declare function runFeishuReplyExperiment(credentials: FeishuCredentials): Promise<void>;

package/dist/daemon/feishu/trigger-input.d.ts

@@ -0,0 +1,36 @@
+export type MessageSnapshot = {
+    messageId: string;
+    messageType: string;
+    senderType: string;
+    senderId?: string | undefined;
+    content: unknown;
+};
+export type FeishuTriggerInput = {
+    source: {
+        messageId: string;
+        chatId: string;
+        chatType: string;
+        senderId?: string | undefined;
+    };
+    message: MessageSnapshot;
+    quotedMessages: MessageSnapshot[];
+};
+export type InboundMessage = {
+    messageId: string;
+    chatId: string;
+    chatType: string;
+    senderId?: string | undefined;
+    senderType: string;
+    messageType: string;
+    content: string;
+    parentMessageId?: string | undefined;
+};
+export type FetchedMessage = {
+    messageId: string;
+    messageType: string;
+    senderType: string;
+    senderId?: string | undefined;
+    content: string;
+    parentMessageId?: string | undefined;
+};
+export declare function buildFeishuTriggerInput(inbound: InboundMessage, fetchMessage: (messageId: string) => Promise<FetchedMessage>): Promise<FeishuTriggerInput>;

package/dist/daemon/index.d.ts

@@ -0,0 +1,6 @@
+export { runDoctor } from "./doctor.js";
+export { runManualTrigger } from "./manual-trigger.js";
+export { submitOutcomeFromCli } from "./outcome/submit.js";
+export type { RuntimeOptions } from "./runtime-options.js";
+export { runScheduleTrigger } from "./schedule-trigger.js";
+export { runBeacon } from "./service.js";

package/dist/daemon/index.js

@@ -0,0 +1,5 @@
+export { runDoctor } from "./doctor.js";
+export { runManualTrigger } from "./manual-trigger.js";
+export { submitOutcomeFromCli } from "./outcome/submit.js";
+export { runScheduleTrigger } from "./schedule-trigger.js";
+export { runBeacon } from "./service.js";

package/dist/daemon/manual-trigger.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeOptions } from "./runtime-options.js";
+export declare function runManualTrigger(configPath: string, profileId: string, input: string, options: RuntimeOptions, output?: (text: string) => Promise<void>): Promise<void>;

package/dist/{manual-trigger.js → daemon/manual-trigger.js}

@@ -13,7 +13,7 @@ function writeStdout(text) {
         process.stdout.write(`${text}\n`, (error) => error ? reject(error) : resolve());
     });
 }
-export async function runManualTrigger(configPath, profileId, input, output = writeStdout) {
+export async function runManualTrigger(configPath, profileId, input, options, output = writeStdout) {
     if (!input.trim())
         throw new Error("Manual Trigger input must not be empty");
     const global = await loadGlobalConfig(configPath);
@@ -41,6 +41,7 @@ export async function runManualTrigger(configPath, profileId, input, output = wr
             },
         };
         const orchestrator = createPiRunOrchestrator({
+            beaconCliPath: options.beaconCliPath,
             config: global,
             runtimeEnvironment,
             profile,

package/dist/daemon/message/gateway.d.ts

@@ -0,0 +1,9 @@
+import type { DeliveryAdapter } from "../run/orchestrator.js";
+export type Acknowledgement = {
+    clear(): Promise<void>;
+};
+export type MessageGateway<Event, ReferencedMessage> = DeliveryAdapter & {
+    run(handleEvent: (event: Event) => Promise<unknown>, shutdown: Promise<void>): Promise<void>;
+    acknowledge(messageId: string): Promise<Acknowledgement>;
+    fetchMessage(messageId: string): Promise<ReferencedMessage>;
+};

package/dist/daemon/outcome/content.d.ts

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import type { CardContent, DeliveryContent, FeedbackContent, FinalOutcomeContent, ReplyContent } from "../domain/types.js";
+export declare const feedbackItemSchema: z.ZodObject<{
+    priority: z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+    }>;
+    summary: z.ZodString;
+}, z.core.$strict>;
+export declare const feedbackContentSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        priority: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+        }>;
+        summary: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const feedbackRecordSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        priority: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+        }>;
+        summary: z.ZodString;
+    }, z.core.$strict>>;
+    submittedAt: z.ZodString;
+}, z.core.$strict>;
+export declare const finalOutcomeContentSchema: z.ZodObject<{
+    reply: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"no_reply">;
+        reason: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"card">;
+        title: z.ZodString;
+        content: z.ZodString;
+        buttons: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            url: z.ZodURL;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>], "kind">;
+    notify: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"card">;
+        title: z.ZodString;
+        content: z.ZodString;
+        buttons: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            url: z.ZodURL;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type OutcomePatch = {
+    reply?: ReplyContent | undefined;
+    notify?: CardContent | undefined;
+    feedback?: FeedbackContent | undefined;
+};
+export declare function parseFinalOutcomeContent(value: unknown): FinalOutcomeContent;
+export declare function parseOutcomePatch(value: unknown): OutcomePatch;
+export declare function mergeOutcome(current: OutcomePatch | undefined, patch: OutcomePatch): OutcomePatch;
+/** Stable English summary when the Agent settles without closing reply/no_reply. */
+export declare const MISSING_REPLY_OUTCOME_SUMMARY = "Expected exactly one of `reply_text`, `reply_card`, or `no_reply`, but the Agent Runtime settled without submitting any";
+export declare function isMissingReplyOutcomeError(error: unknown): boolean;
+export declare function completeOutcome(partial: OutcomePatch): FinalOutcomeContent;
+export declare function renderFinalOutcomeAsText(outcome: FinalOutcomeContent): string;
+export declare function renderDeliveryAsText(content: DeliveryContent): string;

package/dist/daemon/outcome/doctor.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeOptions } from "../runtime-options.js";
+export declare function runOutcomeDoctor(profileId: string, options: RuntimeOptions): Promise<void>;

package/dist/{outcome → daemon/outcome}/doctor.js

@@ -1,4 +1,3 @@
-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";
@@ -13,7 +12,7 @@ const doctorTrigger = {
         content: { text: "Return exactly OUTCOME_CLI_OK." },
     },
 };
-export async function runOutcomeDoctor(profileId) {
+export async function runOutcomeDoctor(profileId, options) {
     const channelsPath = defaultChannelsPath();
     const channels = await loadChannelRegistry(channelsPath);
     const profile = await loadProfile(profileId, undefined, {
@@ -21,7 +20,7 @@ export async function runOutcomeDoctor(profileId) {
         channelsPath,
     });
     const outcomes = await startOutcomeServer();
-    const beaconCliPath = fileURLToPath(new URL("../../dist/cli.js", import.meta.url));
+    const beaconCliPath = options.beaconCliPath;
     try {
         const result = await createProfileRunner(profile, outcomes, beaconCliPath)(doctorTrigger);
         if (result.reply.kind !== "text" ||

package/dist/daemon/outcome/instructions.d.ts

@@ -0,0 +1,3 @@
+export declare const inboundOutOfRoleReply = "\u8FD9\u6761\u6D88\u606F\u4E0D\u5728\u6211\u7684\u804C\u8D23\u8303\u56F4\u5185\u3002";
+export declare const finalOutcomeContractInstructions: readonly ["`reply_text` sends plain text. For an inbound Feishu message, quote-reply that message. For a Schedule, message the Profile admin. For a manual Run, print to the operator. Do not fill `chat_id`.", "`reply_card` sends a titled Markdown card on the conversational channel (inbound quote-reply, or Schedule admin chat). It closes that channel by itself. Do not also call `reply_text` or `no_reply` on the same Run. Do not fill `chat_id`.", "`no_reply` finishes a Run without messaging the conversational channel. Its reason is stored for audit and is never sent. Do not use it on inbound Feishu messages.", "`notify_card` posts a titled Markdown card to this Run's configured notify group. Call it only when this Run has a notify target. Do not fill `chat_id`.", "Which tool to use for a given business result is decided by the Profile persona/task (or the situation), not by these platform lines alone.", "Beacon ignores ordinary assistant final text for Delivery."];
+export declare const feedbackContractInstructions: readonly ["If this Run had a real high or medium problem with instructions, Skills, dependencies, or tools, you may call `submit_feedback` once with one to three items.", "If there are none, do not call it. Do not invent items. Do not report low-priority issues, taste, or problems you already worked around without needing a platform change."];

package/dist/daemon/outcome/server.d.ts

@@ -0,0 +1,20 @@
+import type { FeedbackRecord, FinalOutcomeContent } from "../domain/types.js";
+export type OutcomeBinding = {
+    socketPath: string;
+    runToken: string;
+};
+export type OutcomeSubmission = {
+    binding: OutcomeBinding;
+    take(): FinalOutcomeContent;
+    takeFeedback(): FeedbackRecord | undefined;
+    cancel(): void;
+};
+export type OutcomeSink = {
+    openRun(): OutcomeSubmission;
+};
+export type OutcomeServer = OutcomeSink & {
+    close(): Promise<void>;
+};
+export declare function startOutcomeServer(options?: {
+    maxRequestBytes?: number | undefined;
+}): Promise<OutcomeServer>;

package/dist/daemon/outcome/submit.d.ts

@@ -0,0 +1,5 @@
+import type { FinalOutcomeContent } from "../domain/types.js";
+import { completeOutcome, mergeOutcome, type OutcomePatch } from "./content.js";
+export declare function submitOutcome(socketPath: string, runToken: string, outcome: OutcomePatch | FinalOutcomeContent): Promise<void>;
+export declare function submitOutcomeFromCli(): Promise<void>;
+export { completeOutcome, mergeOutcome };

package/dist/daemon/run/create-pi-orchestrator.d.ts

@@ -0,0 +1,17 @@
+import type { GlobalConfig } from "../config/global.js";
+import type { Profile } from "../config/profile.js";
+import type { OutcomeServer } from "../outcome/server.js";
+import type { TriggerStore } from "../state/trigger-store.js";
+import { type DeliveryAdapter, RunOrchestrator } from "./orchestrator.js";
+import type { RunQueue } from "./queue.js";
+export type PiOrchestratorConfig = Pick<GlobalConfig, "pi" | "runs">;
+export declare function createPiRunOrchestrator(options: {
+    beaconCliPath: string;
+    config: PiOrchestratorConfig;
+    runtimeEnvironment: NodeJS.ProcessEnv;
+    profile: Profile;
+    store: TriggerStore;
+    queue: RunQueue;
+    outcomes: OutcomeServer;
+    delivery: DeliveryAdapter;
+}): RunOrchestrator;

package/dist/{run → daemon/run}/create-pi-orchestrator.js

@@ -1,4 +1,3 @@
-import { fileURLToPath } from "node:url";
 import { runPiAgent } from "../runtime/pi-rpc.js";
 import { RunOrchestrator } from "./orchestrator.js";
 export function createPiRunOrchestrator(options) {
@@ -7,7 +6,7 @@ export function createPiRunOrchestrator(options) {
         store: options.store,
         queue: options.queue,
         outcomes: options.outcomes,
-        beaconCliPath: fileURLToPath(new URL("../../dist/cli.js", import.meta.url)),
+        beaconCliPath: options.beaconCliPath,
         sessionDirectory: options.config.pi.sessionDirectory,
         runAgent: (request) => runPiAgent(request, {
             executable: options.config.pi.executable,

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

@@ -0,0 +1,61 @@
+import type { Profile } from "../config/profile.js";
+import type { DeliveryContent, DeliveryTarget, FailureCode, MessageSnapshot, TriggerInput, TriggerRecord } from "../domain/types.js";
+import type { OutcomeServer } from "../outcome/server.js";
+import type { TriggerStore } from "../state/trigger-store.js";
+import type { AgentRuntimeRunner } from "./profile-runner.js";
+import type { RunQueue } from "./queue.js";
+export type DeliveryAdapter = {
+    deliver(target: DeliveryTarget, outcome: DeliveryContent, deliveryId: string): Promise<{
+        providerRequestId?: string | undefined;
+    }>;
+};
+export type RunOrchestratorOptions = {
+    profile: Profile;
+    store: TriggerStore;
+    queue: RunQueue;
+    outcomes: OutcomeServer;
+    beaconCliPath: string;
+    runAgent: AgentRuntimeRunner;
+    delivery: DeliveryAdapter;
+    sessionDirectory: string;
+    now?: (() => Date) | undefined;
+    id?: (() => string) | undefined;
+};
+/** Compact settle-side hint for outcome_missing (Feishu / admin). */
+export declare function formatSettleFailureHint(parts: {
+    stopReason?: string | undefined;
+    thinking?: string | undefined;
+    text?: string | undefined;
+}): string | undefined;
+/** User-visible (Feishu/admin) failure text. Keep codes stable; prefer concrete reasons. */
+export declare function formatFailureReplyText(runId: string, failure?: {
+    code: FailureCode;
+    summary: string;
+}): string;
+export type ContinuedPiSession = {
+    sessionId: string;
+    sessionPath: string;
+    systemPrompt?: string | undefined;
+};
+/**
+ * Walk a Feishu quote chain (oldest → newest) from the direct parent backward
+ * and reuse the first Beacon Delivery's Pi session.
+ */
+export declare function resolveContinuedPiSession(quotedMessages: readonly MessageSnapshot[], findByDeliveredMessageId: (messageId: string) => Promise<TriggerRecord | undefined>): Promise<ContinuedPiSession | undefined>;
+export declare class RunOrchestrator {
+    private readonly options;
+    private readonly now;
+    private readonly id;
+    constructor(options: RunOrchestratorOptions);
+    private timestamp;
+    private record;
+    private agentSystemPrompt;
+    private triggerFor;
+    private newRun;
+    private deliverField;
+    private deliverOutcome;
+    private fail;
+    private execute;
+    process(triggerKey: string, normalize: () => Promise<TriggerInput>): Promise<void>;
+    recover(): Promise<void>;
+}

package/dist/daemon/run/profile-runner.d.ts

@@ -0,0 +1,9 @@
+import type { Profile } from "../config/profile.js";
+import type { FinalOutcomeContent } from "../domain/types.js";
+import type { FeishuTriggerInput } from "../feishu/trigger-input.js";
+import type { OutcomeSink } from "../outcome/server.js";
+import { type PiRunRequest, type PiRunResult } from "../runtime/pi-rpc.js";
+export type RunProfile = (trigger: FeishuTriggerInput) => Promise<FinalOutcomeContent>;
+export type AgentRuntimeRunner = (request: PiRunRequest) => Promise<PiRunResult>;
+export declare function formatFeishuTriggerPrompt(trigger: FeishuTriggerInput): string;
+export declare function createProfileRunner(profile: Profile, outcomes: OutcomeSink, beaconCliPath: string, runAgent?: AgentRuntimeRunner): RunProfile;

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

@@ -0,0 +1,20 @@
+export type QueueSubmission = {
+    accepted: false;
+} | {
+    accepted: true;
+    completion: Promise<void>;
+};
+export declare class RunQueue {
+    readonly maxConcurrent: number;
+    readonly maxQueued: number;
+    private active;
+    private readonly pending;
+    private readonly waiting;
+    constructor(maxConcurrent: number, maxQueued: number);
+    enqueue(task: () => Promise<void>): QueueSubmission;
+    /** Wait for admission without dropping already accepted, persisted event work. */
+    enqueueWhenAvailable(task: () => Promise<void>): Promise<void>;
+    private promoteWaiting;
+    private execute;
+    private drain;
+}

package/dist/daemon/runtime/pi-doctor.d.ts

@@ -0,0 +1 @@
+export declare function runPiDoctor(provider?: string, model?: string): Promise<void>;

package/dist/daemon/runtime/pi-outcome-extension.d.ts

@@ -0,0 +1,43 @@
+import type { CardContent, FeedbackContent, FinalOutcomeContent } from "../domain/types.js";
+type ToolResult = {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    details: {
+        submitted: true;
+    };
+};
+export type TextOutcomeToolParams = {
+    text: string;
+};
+export type NoReplyOutcomeToolParams = {
+    reason: string;
+};
+export type CardOutcomeToolParams = {
+    title: string;
+    content: string;
+    buttons?: Array<{
+        label: string;
+        url: string;
+    }>;
+};
+export type FeedbackToolParams = {
+    items: FeedbackContent["items"];
+};
+type ExtensionApi = {
+    registerTool<TParams>(tool: {
+        name: string;
+        label: string;
+        description: string;
+        parameters: object;
+        execute(toolCallId: string, params: TParams, signal: AbortSignal): Promise<ToolResult>;
+    }): void;
+};
+export declare function replyTextFromToolParams(params: TextOutcomeToolParams): FinalOutcomeContent;
+export declare function replyCardFromToolParams(params: CardOutcomeToolParams): FinalOutcomeContent;
+export declare function noReplyFromToolParams(params: NoReplyOutcomeToolParams): FinalOutcomeContent;
+export declare function notifyCardFromToolParams(params: CardOutcomeToolParams): CardContent;
+export declare function feedbackFromToolParams(params: FeedbackToolParams): FeedbackContent;
+export default function registerOutcomeTools(pi: ExtensionApi): void;
+export {};

package/dist/daemon/runtime/pi-rpc.d.ts

@@ -0,0 +1,42 @@
+import type { OutcomeBinding } from "../outcome/server.js";
+type PiOutcomeBinding = OutcomeBinding & {
+    cliPath: string;
+};
+export type PiRunRequest = {
+    prompt: string;
+    workspace: string;
+    provider?: string | undefined;
+    model?: string | undefined;
+    systemPrompt?: string | undefined;
+    outcome?: PiOutcomeBinding | undefined;
+    session?: {
+        id: string;
+        path: string;
+        name?: string | undefined;
+    } | undefined;
+};
+export type PiRunResult = {
+    text: string;
+    provider: string;
+    model: string;
+    /** Final assistant stopReason when Pi settles cleanly (usually `stop`). */
+    stopReason?: string | undefined;
+    /** Truncation-ready last thinking text from the final assistant message. */
+    thinking?: string | undefined;
+};
+export type PiRuntimeOptions = {
+    executable?: string | undefined;
+    timeoutMs?: number | undefined;
+    environment?: NodeJS.ProcessEnv | undefined;
+    runtimeEnvironment?: NodeJS.ProcessEnv | undefined;
+    terminateGraceMs?: number | undefined;
+    maxFrameBytes?: number | undefined;
+};
+export declare class PiRuntimeError extends Error {
+    readonly code: "runtime_spawn_failed" | "runtime_protocol_error" | "runtime_timeout" | "runtime_exit_failed";
+    constructor(code: "runtime_spawn_failed" | "runtime_protocol_error" | "runtime_timeout" | "runtime_exit_failed", message: string, options?: ErrorOptions);
+}
+/** Collect thinking / reasoning blocks from an assistant message content array. */
+export declare function collectThinking(content: unknown[]): string;
+export declare function runPiAgent(request: PiRunRequest, options?: PiRuntimeOptions): Promise<PiRunResult>;
+export {};

package/dist/{runtime → daemon/runtime}/pi-rpc.js

@@ -83,7 +83,9 @@ function buildArguments(request) {
     if (request.systemPrompt)
         args.push("--system-prompt", request.systemPrompt);
     if (request.outcome) {
-        args.push("--extension", fileURLToPath(new URL("../../dist/runtime/pi-outcome-extension.js", import.meta.url)));
+        args.push("--extension", fileURLToPath(new URL(import.meta.url.endsWith(".ts")
+            ? "../../dist/runtime/pi-outcome-extension.js"
+            : "./pi-outcome-extension.js", import.meta.url)));
     }
     return args;
 }

package/dist/daemon/runtime/system-prompt.d.ts

@@ -0,0 +1,10 @@
+import type { Profile } from "../config/profile.js";
+import type { DeliveryTarget, TriggerInput } from "../domain/types.js";
+export type AgentSystemPromptTrigger = {
+    kind: TriggerInput["kind"];
+    scheduleId?: string | undefined;
+    notify: boolean;
+};
+export declare function agentSystemPromptTrigger(input: TriggerInput | undefined, notifyTarget: DeliveryTarget | undefined): AgentSystemPromptTrigger;
+export declare function profilePromptDigest(profile: Pick<Profile, "persona" | "task">): string;
+export declare function buildAgentSystemPrompt(profile: Pick<Profile, "persona" | "task" | "workspace">, trigger: AgentSystemPromptTrigger): string;

package/dist/daemon/runtime-options.d.ts

@@ -0,0 +1,4 @@
+export type RuntimeOptions = {
+    /** Executable JavaScript CLI entry used by agent outcome submissions. */
+    beaconCliPath: string;
+};

package/dist/daemon/runtime-options.js

@@ -0,0 +1 @@
+export {};

package/dist/daemon/schedule/cron.d.ts

@@ -0,0 +1,2 @@
+export declare function occurrencesBetween(cron: string, timezone: string, afterExclusive: Date, throughInclusive: Date, limit: number): Date[];
+export declare function nextOccurrence(cron: string, timezone: string, afterExclusive: Date): Date;