@hyperdrive.bot/paseo-server 0.2.6

package/dist/server/server/voice/voice-turn-controller.js

@@ -0,0 +1,393 @@
+import { Buffer } from "node:buffer";
+import { v4 as uuidv4 } from "uuid";
+import { Pcm16MonoResampler } from "../agent/pcm16-resampler.js";
+import { parsePcmRateFromFormat } from "../speech/audio.js";
+const VOICE_FINAL_TRANSCRIPT_TIMEOUT_MS = 10000;
+const FILLER_PARTIAL_WORDS = new Set([
+    "uh",
+    "um",
+    "ah",
+    "eh",
+    "er",
+    "hmm",
+    "mm",
+    "mmm",
+    "mhm",
+    "huh",
+    "uhhuh",
+    "uh-huh",
+    "oh",
+]);
+function isFillerOnlyPartial(transcript) {
+    const tokens = transcript
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}\s'-]/gu, "")
+        .split(/\s+/)
+        .filter(Boolean);
+    if (tokens.length === 0) {
+        return true;
+    }
+    return tokens.every((token) => FILLER_PARTIAL_WORDS.has(token));
+}
+export function createVoiceTurnController(params) {
+    const detector = params.turnDetection.createSession({
+        logger: params.logger.child({ component: "turn-detection" }),
+    });
+    let state = { status: "idle" };
+    let resampler = null;
+    let sttSession = null;
+    let sttResampler = null;
+    let inputRate = detector.requiredSampleRate;
+    let sttInputRate = 0;
+    let queued = Promise.resolve();
+    let activeTranscriptSegmentId = null;
+    let partialTranscriptFired = false;
+    let reconnectAttemptedForTurn = false;
+    const sealedTranscriptSegmentIds = new Set();
+    let currentFinalizingTurn = null;
+    function fail(error) {
+        params.callbacks.onError(error instanceof Error ? error : new Error(String(error)));
+    }
+    function firePartialTranscript(segmentId, transcript) {
+        if (partialTranscriptFired || state.status !== "capturing") {
+            return;
+        }
+        partialTranscriptFired = true;
+        void runSerial(async () => {
+            await params.callbacks.onPartialTranscript({ segmentId, transcript });
+        });
+    }
+    function clearFinalizingTurnTimeout() {
+        if (currentFinalizingTurn) {
+            clearTimeout(currentFinalizingTurn.timeout);
+        }
+    }
+    function getFinalizingTurnForSegment(segmentId) {
+        if (!currentFinalizingTurn) {
+            return null;
+        }
+        if (currentFinalizingTurn.committedSegmentIds.includes(segmentId)) {
+            return currentFinalizingTurn;
+        }
+        if (currentFinalizingTurn.committedSegmentIds.length > 0) {
+            return null;
+        }
+        if (activeTranscriptSegmentId && activeTranscriptSegmentId !== segmentId) {
+            return null;
+        }
+        return currentFinalizingTurn;
+    }
+    function getOrderedFinalSegmentIds(turn) {
+        if (turn.committedSegmentIds.length === 0) {
+            return [...turn.finalTranscriptSegmentIds];
+        }
+        return turn.committedSegmentIds.filter((segmentId) => turn.finalTranscriptSegmentIds.has(segmentId));
+    }
+    function assembleFinalTranscript(turn) {
+        const orderedFinalSegmentIds = getOrderedFinalSegmentIds(turn);
+        const transcript = orderedFinalSegmentIds
+            .map((segmentId) => turn.transcriptsBySegmentId.get(segmentId)?.trim() ?? "")
+            .filter((segment) => segment.length > 0)
+            .join(" ")
+            .trim();
+        const orderedFinalMeta = orderedFinalSegmentIds
+            .map((segmentId) => turn.transcriptMetaBySegmentId.get(segmentId))
+            .filter((meta) => Boolean(meta));
+        const language = orderedFinalMeta.find((meta) => meta.language)?.language;
+        const singleSegmentMeta = orderedFinalMeta.length === 1 ? orderedFinalMeta[0] : null;
+        const allLowConfidence = orderedFinalMeta.length > 0 &&
+            orderedFinalMeta.every((meta) => meta.isLowConfidence === true);
+        return {
+            segmentId: turn.committedSegmentIds[0] ?? orderedFinalSegmentIds[0] ?? turn.turnId,
+            transcript,
+            ...(language ? { language } : {}),
+            ...(singleSegmentMeta?.avgLogprob !== undefined
+                ? { avgLogprob: singleSegmentMeta.avgLogprob }
+                : {}),
+            ...(allLowConfidence ? { isLowConfidence: true } : {}),
+            durationMs: Math.max(0, Date.now() - turn.startedAt),
+        };
+    }
+    function fireFinalTranscript(turn, reason) {
+        if (turn.fired || currentFinalizingTurn?.turnId !== turn.turnId) {
+            return;
+        }
+        turn.fired = true;
+        clearTimeout(turn.timeout);
+        currentFinalizingTurn = null;
+        const finalTranscript = assembleFinalTranscript(turn);
+        if (reason === "timeout") {
+            params.logger.warn({
+                turnId: turn.turnId,
+                committedSegments: turn.committedSegmentIds.length,
+                receivedFinals: turn.finalTranscriptSegmentIds.size,
+                timeoutMs: VOICE_FINAL_TRANSCRIPT_TIMEOUT_MS,
+                transcriptLength: finalTranscript.transcript.length,
+            }, "voice_turn.final_transcript_timeout");
+        }
+        void runSerial(async () => {
+            await params.callbacks.onFinalTranscript(finalTranscript);
+        });
+    }
+    function maybeFireFinalTranscript(turn) {
+        if (turn.fired || turn.committedSegmentIds.length === 0) {
+            return;
+        }
+        const allCommittedSegmentsFinal = turn.committedSegmentIds.every((segmentId) => turn.finalTranscriptSegmentIds.has(segmentId));
+        if (allCommittedSegmentsFinal) {
+            fireFinalTranscript(turn, "complete");
+        }
+    }
+    async function reconnectSttSession() {
+        const previousSession = sttSession;
+        sttSession = null;
+        sttResampler = null;
+        sttInputRate = 0;
+        previousSession?.close();
+        try {
+            const nextSession = createSttSession();
+            await nextSession.connect();
+            sttSession = nextSession;
+            params.logger.info("voice_turn.stt_reconnected");
+        }
+        catch (error) {
+            fail(error);
+            params.logger.warn({ err: error }, "voice_turn.stt_reconnect_failed");
+        }
+    }
+    function handleSttError(error) {
+        fail(error);
+        params.logger.warn({ err: error }, "voice_turn.stt_error");
+        if (reconnectAttemptedForTurn) {
+            sttSession?.close();
+            sttSession = null;
+            return;
+        }
+        reconnectAttemptedForTurn = true;
+        void runSerial(reconnectSttSession);
+    }
+    function handleFinalSttTranscript(event) {
+        const turn = getFinalizingTurnForSegment(event.segmentId);
+        if (!turn || turn.fired) {
+            return;
+        }
+        turn.transcriptsBySegmentId.set(event.segmentId, event.transcript);
+        turn.finalTranscriptSegmentIds.add(event.segmentId);
+        turn.transcriptMetaBySegmentId.set(event.segmentId, {
+            ...(event.language ? { language: event.language } : {}),
+            ...(event.avgLogprob !== undefined ? { avgLogprob: event.avgLogprob } : {}),
+            ...(event.isLowConfidence !== undefined ? { isLowConfidence: event.isLowConfidence } : {}),
+        });
+        maybeFireFinalTranscript(turn);
+    }
+    function handlePartialSttTranscript(event) {
+        if (state.status !== "capturing" || partialTranscriptFired) {
+            return;
+        }
+        if (sealedTranscriptSegmentIds.has(event.segmentId)) {
+            return;
+        }
+        if (activeTranscriptSegmentId && event.segmentId !== activeTranscriptSegmentId) {
+            return;
+        }
+        const transcript = event.transcript.trim();
+        if (!transcript) {
+            return;
+        }
+        activeTranscriptSegmentId = event.segmentId;
+        if (isFillerOnlyPartial(transcript)) {
+            return;
+        }
+        firePartialTranscript(event.segmentId, transcript);
+    }
+    function handleSttTranscript(event) {
+        if (event.isFinal) {
+            handleFinalSttTranscript(event);
+            return;
+        }
+        handlePartialSttTranscript(event);
+    }
+    function createSttSession() {
+        const session = params.stt.createSession({
+            logger: params.logger.child({ component: "stt" }),
+            language: params.sttLanguage ?? "en",
+        });
+        session.on("transcript", handleSttTranscript);
+        session.on("committed", ({ segmentId }) => {
+            sealedTranscriptSegmentIds.add(segmentId);
+            if (state.status === "capturing" && !activeTranscriptSegmentId) {
+                activeTranscriptSegmentId = segmentId;
+            }
+            const turn = currentFinalizingTurn;
+            if (turn && !turn.committedSegmentIds.includes(segmentId)) {
+                turn.committedSegmentIds.push(segmentId);
+                maybeFireFinalTranscript(turn);
+            }
+        });
+        session.on("error", handleSttError);
+        return session;
+    }
+    function runSerial(task) {
+        queued = queued.then(task).catch((error) => {
+            fail(error);
+        });
+        return queued;
+    }
+    function updateDetectorResampler(parsedInputRate) {
+        if (parsedInputRate === inputRate) {
+            return;
+        }
+        inputRate = parsedInputRate;
+        resampler =
+            inputRate === detector.requiredSampleRate
+                ? null
+                : new Pcm16MonoResampler({
+                    inputRate,
+                    outputRate: detector.requiredSampleRate,
+                });
+    }
+    function updateSttResampler(session, parsedInputRate) {
+        if (parsedInputRate === sttInputRate) {
+            return;
+        }
+        sttInputRate = parsedInputRate;
+        sttResampler =
+            sttInputRate === session.requiredSampleRate
+                ? null
+                : new Pcm16MonoResampler({
+                    inputRate: sttInputRate,
+                    outputRate: session.requiredSampleRate,
+                });
+    }
+    function pcmForDetector(pcm16) {
+        return resampler === null ? pcm16 : resampler.processChunk(pcm16);
+    }
+    function pcmForStt(session, pcm16, detectorPcm16) {
+        if (session.requiredSampleRate === detector.requiredSampleRate) {
+            return detectorPcm16;
+        }
+        if (sttResampler === null) {
+            return pcm16;
+        }
+        return sttResampler.processChunk(pcm16);
+    }
+    async function handleSpeechStarted() {
+        if (state.status === "capturing") {
+            return;
+        }
+        await params.callbacks.onSpeechStarted();
+        const startedAt = Date.now();
+        activeTranscriptSegmentId = null;
+        partialTranscriptFired = false;
+        reconnectAttemptedForTurn = false;
+        clearFinalizingTurnTimeout();
+        currentFinalizingTurn = null;
+        state = {
+            status: "capturing",
+            utteranceId: uuidv4(),
+            startedAt,
+        };
+        params.logger.info({
+            utteranceId: state.utteranceId,
+        }, "voice_turn.speech_started");
+    }
+    async function handleSpeechStopped() {
+        if (state.status !== "capturing") {
+            return;
+        }
+        const turnId = state.utteranceId;
+        const startedAt = state.startedAt;
+        const endedAt = Date.now();
+        state = { status: "listening" };
+        const finalizingTurn = {
+            turnId,
+            startedAt,
+            committedSegmentIds: [],
+            transcriptsBySegmentId: new Map(),
+            finalTranscriptSegmentIds: new Set(),
+            transcriptMetaBySegmentId: new Map(),
+            timeout: setTimeout(() => {
+                fireFinalTranscript(finalizingTurn, "timeout");
+            }, VOICE_FINAL_TRANSCRIPT_TIMEOUT_MS),
+            fired: false,
+        };
+        currentFinalizingTurn = finalizingTurn;
+        detector.reset();
+        try {
+            sttSession?.commit();
+        }
+        catch (error) {
+            handleSttError(error);
+        }
+        await params.callbacks.onSpeechStopped();
+        params.logger.info({
+            utteranceAgeMs: Math.max(0, endedAt - startedAt),
+        }, "voice_turn.speech_stopped");
+    }
+    detector.on("speech_started", () => {
+        void runSerial(handleSpeechStarted);
+    });
+    detector.on("speech_stopped", () => {
+        void runSerial(handleSpeechStopped);
+    });
+    detector.on("error", fail);
+    return {
+        async start() {
+            sttSession = createSttSession();
+            await sttSession.connect();
+            await detector.connect();
+            state = { status: "listening" };
+        },
+        async stop() {
+            await runSerial(async () => {
+                clearFinalizingTurnTimeout();
+                detector.close();
+                sttSession?.close();
+                resampler?.reset();
+                sttResampler?.reset();
+                resampler = null;
+                sttResampler = null;
+                sttSession = null;
+                currentFinalizingTurn = null;
+                state = { status: "idle" };
+            });
+        },
+        async appendClientChunk(input) {
+            await runSerial(async () => {
+                if (state.status === "idle") {
+                    return;
+                }
+                const pcm16 = Buffer.from(input.audioBase64, "base64");
+                if (pcm16.length === 0) {
+                    return;
+                }
+                const parsedInputRate = parsePcmRateFromFormat(input.format, detector.requiredSampleRate) ??
+                    detector.requiredSampleRate;
+                updateDetectorResampler(parsedInputRate);
+                const currentSttSession = sttSession;
+                if (currentSttSession) {
+                    updateSttResampler(currentSttSession, parsedInputRate);
+                }
+                const detectorPcm16 = pcmForDetector(pcm16);
+                const sttPcm16 = currentSttSession
+                    ? pcmForStt(currentSttSession, pcm16, detectorPcm16)
+                    : null;
+                if (detectorPcm16.length === 0 && (!sttPcm16 || sttPcm16.length === 0)) {
+                    return;
+                }
+                if (detectorPcm16.length > 0) {
+                    detector.appendPcm16(detectorPcm16);
+                }
+                if (sttPcm16 && sttPcm16.length > 0) {
+                    try {
+                        currentSttSession?.appendPcm16(sttPcm16);
+                    }
+                    catch (error) {
+                        handleSttError(error);
+                    }
+                }
+            });
+        },
+    };
+}
+//# sourceMappingURL=voice-turn-controller.js.map

package/dist/server/server/voice-config.d.ts

@@ -0,0 +1,15 @@
+export declare function stripVoiceModeSystemPrompt(existing?: string): string | undefined;
+export declare function buildVoiceModeSystemPrompt(existing: string | undefined, enabled: boolean): string;
+export declare function wrapSpokenInput(text: string): string;
+export declare function buildVoiceAgentMcpServerConfig(params: {
+    command: string;
+    baseArgs: string[];
+    socketPath: string;
+    env?: Record<string, string>;
+}): {
+    type: "stdio";
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+};
+//# sourceMappingURL=voice-config.d.ts.map

package/dist/server/server/voice-config.js

@@ -0,0 +1,54 @@
+const VOICE_PROMPT_BLOCK_START = "<paseo_voice_mode>";
+const VOICE_PROMPT_BLOCK_END = "</paseo_voice_mode>";
+const VOICE_AGENT_SYSTEM_INSTRUCTION = [
+    "Paseo voice mode is now on.",
+    "You are the Paseo voice assistant.",
+    "The user cannot see your chat messages or tool calls.",
+    "Always use the speak tool for all user-facing communication.",
+    "Before calling any non-speak tool, first call speak with a short acknowledgement of what you heard and what you will do next.",
+    "For long-running work, use speak to provide progress updates before and during execution.",
+    "Treat the user input as transcribed speech.",
+    "If the user intent is clear, proceed without extra confirmation.",
+    "If the transcription seems incomplete, cut off, ambiguous, or may contain a non-obvious mistake or misspelling, ask a clarifying question via speak before taking action.",
+    "Use concise plain language suitable for speech output.",
+].join(" ");
+const VOICE_AGENT_DISABLED_INSTRUCTION = [
+    "Paseo voice mode is now off.",
+    "Ignore any earlier Paseo voice mode instructions in this thread.",
+].join(" ");
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function makeVoicePromptBlockRegex() {
+    return new RegExp(`${escapeRegExp(VOICE_PROMPT_BLOCK_START)}[\\s\\S]*?${escapeRegExp(VOICE_PROMPT_BLOCK_END)}`, "g");
+}
+export function stripVoiceModeSystemPrompt(existing) {
+    const trimmed = existing?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const stripped = trimmed.replace(makeVoicePromptBlockRegex(), "").trim();
+    return stripped.length > 0 ? stripped : undefined;
+}
+export function buildVoiceModeSystemPrompt(existing, enabled) {
+    const basePrompt = stripVoiceModeSystemPrompt(existing);
+    const voiceInstruction = enabled
+        ? VOICE_AGENT_SYSTEM_INSTRUCTION
+        : VOICE_AGENT_DISABLED_INSTRUCTION;
+    const voiceBlock = [VOICE_PROMPT_BLOCK_START, voiceInstruction, VOICE_PROMPT_BLOCK_END].join("\n");
+    return [basePrompt, voiceBlock]
+        .filter((entry) => typeof entry === "string" && entry.length > 0)
+        .join("\n\n");
+}
+export function wrapSpokenInput(text) {
+    return `<spoken-input>\n${text}\n</spoken-input>\n<instruction>This message was spoken by the user. Respond using the speak tool only, not normal messages, because the user may not be looking at the chat.</instruction>`;
+}
+export function buildVoiceAgentMcpServerConfig(params) {
+    return {
+        type: "stdio",
+        command: params.command,
+        args: [...params.baseArgs, "--socket", params.socketPath],
+        ...(params.env ? { env: params.env } : {}),
+    };
+}
+//# sourceMappingURL=voice-config.js.map

package/dist/server/server/voice-permission-policy.d.ts

@@ -0,0 +1,4 @@
+import type { AgentPermissionRequest } from "./agent/agent-sdk-types.js";
+/** Voice assistant policy: only allow the speak tool. */
+export declare function isVoicePermissionAllowed(request: AgentPermissionRequest): boolean;
+//# sourceMappingURL=voice-permission-policy.d.ts.map

package/dist/server/server/voice-permission-policy.js

@@ -0,0 +1,13 @@
+import { isSpeakToolName } from "@hyperdrive.bot/paseo-protocol/tool-name-normalization";
+/** Voice assistant policy: only allow the speak tool. */
+export function isVoicePermissionAllowed(request) {
+    if (request.kind !== "tool") {
+        return false;
+    }
+    const normalizedName = request.name.trim().toLowerCase();
+    if (!normalizedName) {
+        return false;
+    }
+    return isSpeakToolName(normalizedName);
+}
+//# sourceMappingURL=voice-permission-policy.js.map

package/dist/server/server/voice-types.d.ts

@@ -0,0 +1,12 @@
+export type VoiceSpeakHandler = (params: {
+    text: string;
+    callerAgentId: string;
+    signal?: AbortSignal;
+}) => Promise<void>;
+export interface VoiceCallerContext {
+    childAgentDefaultLabels?: Record<string, string>;
+    lockedCwd?: string;
+    allowCustomCwd?: boolean;
+    enableVoiceTools?: boolean;
+}
+//# sourceMappingURL=voice-types.d.ts.map

package/dist/server/server/voice-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=voice-types.js.map

package/dist/server/server/watch/composer-dictate.d.ts

@@ -0,0 +1,42 @@
+import type { Logger } from "pino";
+export interface HandleWatchComposerDictateParams {
+    sessionId: string;
+    text: string;
+    resolveAgentId: (identifier: string) => Promise<{
+        ok: true;
+        agentId: string;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    sendPrompt: (args: {
+        agentId: string;
+        prompt: string;
+    }) => Promise<unknown>;
+    logger: Logger;
+}
+export type WatchComposerDictateResult = {
+    ok: true;
+    agentId: string;
+} | {
+    ok: false;
+    error: "unknown_session" | "empty_text" | "send_failed";
+};
+/**
+ * Route a watch-originated dictation through the existing composer-send pipeline.
+ *
+ * A watch `sessionId` is an agent identifier: it is resolved by the same
+ * `resolveAgentIdentifier` resolver the phone send path uses (injected here as
+ * `resolveAgentId`), then the dictated text is forwarded to the existing
+ * `sendPromptToAgent` path (injected as `sendPrompt`). The dictation carries no
+ * images/attachments, so the prompt is the trimmed plain string — the exact shape
+ * `buildAgentPrompt` returns for text-only input.
+ *
+ * NEVER throws. Empty text, an unknown/ambiguous session, AND an internal send
+ * failure are all returned as a typed `{ ok: false }` result. An unhandled throw
+ * over the relay WebSocket would break ALL phone↔daemon traffic, not just the
+ * watch path — so the `sendPrompt` call is wrapped and any throw is mapped to
+ * `send_failed`.
+ */
+export declare function handleWatchComposerDictate(params: HandleWatchComposerDictateParams): Promise<WatchComposerDictateResult>;
+//# sourceMappingURL=composer-dictate.d.ts.map

package/dist/server/server/watch/composer-dictate.js

@@ -0,0 +1,37 @@
+/**
+ * Route a watch-originated dictation through the existing composer-send pipeline.
+ *
+ * A watch `sessionId` is an agent identifier: it is resolved by the same
+ * `resolveAgentIdentifier` resolver the phone send path uses (injected here as
+ * `resolveAgentId`), then the dictated text is forwarded to the existing
+ * `sendPromptToAgent` path (injected as `sendPrompt`). The dictation carries no
+ * images/attachments, so the prompt is the trimmed plain string — the exact shape
+ * `buildAgentPrompt` returns for text-only input.
+ *
+ * NEVER throws. Empty text, an unknown/ambiguous session, AND an internal send
+ * failure are all returned as a typed `{ ok: false }` result. An unhandled throw
+ * over the relay WebSocket would break ALL phone↔daemon traffic, not just the
+ * watch path — so the `sendPrompt` call is wrapped and any throw is mapped to
+ * `send_failed`.
+ */
+export async function handleWatchComposerDictate(params) {
+    const { sessionId, text, resolveAgentId, sendPrompt, logger } = params;
+    const trimmed = text.trim();
+    if (trimmed.length === 0) {
+        return { ok: false, error: "empty_text" };
+    }
+    const resolved = await resolveAgentId(sessionId);
+    if (!resolved.ok) {
+        logger.warn({ sessionId, error: resolved.error }, "watch.composerDictate unknown session");
+        return { ok: false, error: "unknown_session" };
+    }
+    try {
+        await sendPrompt({ agentId: resolved.agentId, prompt: trimmed });
+    }
+    catch (err) {
+        logger.warn({ sessionId, agentId: resolved.agentId, err }, "watch.composerDictate send failed");
+        return { ok: false, error: "send_failed" };
+    }
+    return { ok: true, agentId: resolved.agentId };
+}
+//# sourceMappingURL=composer-dictate.js.map

package/dist/server/server/watch/notification-action.d.ts

@@ -0,0 +1,38 @@
+import type { Logger } from "pino";
+import { type PermissionResponseAgentManager } from "../agent/permission-response.js";
+import type { WatchNotificationRegistry } from "./notification-registry.js";
+export interface HandleWatchNotificationActionParams {
+    agentManager: PermissionResponseAgentManager;
+    registry: WatchNotificationRegistry;
+    notificationId: string;
+    action: "approve" | "deny" | "reply";
+    replyText?: string;
+    logger: Logger;
+}
+export type WatchNotificationActionResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: "unknown_notification" | "missing_reply_text";
+};
+/**
+ * Resolve a pending agent permission from a watch-originated notification action.
+ *
+ * Looks up `notificationId` in the watch-notification registry and forwards the
+ * mapped action to the existing `respondToAgentPermission` path. NEVER throws on
+ * bad input — an unknown/expired notification or a `reply` without text returns a
+ * typed `{ ok: false }` result. (An unhandled throw over the relay WebSocket would
+ * break ALL phone↔daemon traffic, not just the watch path.)
+ *
+ * Action mapping:
+ *   - `approve` → `{ behavior: "allow" }`
+ *   - `deny`    → `{ behavior: "deny" }`
+ *   - `reply`   → `{ behavior: "deny", message: replyText }`
+ *     (`message` exists only on the `deny` variant of `AgentPermissionResponse`,
+ *      so a textual reply is modeled as deny-with-message.)
+ *
+ * On a successful resolve the registry entry is deleted, so a duplicate/late tap
+ * on the same notification returns `unknown_notification` instead of double-resolving.
+ */
+export declare function handleWatchNotificationAction(params: HandleWatchNotificationActionParams): Promise<WatchNotificationActionResult>;
+//# sourceMappingURL=notification-action.d.ts.map

package/dist/server/server/watch/notification-action.js

@@ -0,0 +1,54 @@
+import { respondToAgentPermission, } from "../agent/permission-response.js";
+/**
+ * Resolve a pending agent permission from a watch-originated notification action.
+ *
+ * Looks up `notificationId` in the watch-notification registry and forwards the
+ * mapped action to the existing `respondToAgentPermission` path. NEVER throws on
+ * bad input — an unknown/expired notification or a `reply` without text returns a
+ * typed `{ ok: false }` result. (An unhandled throw over the relay WebSocket would
+ * break ALL phone↔daemon traffic, not just the watch path.)
+ *
+ * Action mapping:
+ *   - `approve` → `{ behavior: "allow" }`
+ *   - `deny`    → `{ behavior: "deny" }`
+ *   - `reply`   → `{ behavior: "deny", message: replyText }`
+ *     (`message` exists only on the `deny` variant of `AgentPermissionResponse`,
+ *      so a textual reply is modeled as deny-with-message.)
+ *
+ * On a successful resolve the registry entry is deleted, so a duplicate/late tap
+ * on the same notification returns `unknown_notification` instead of double-resolving.
+ */
+export async function handleWatchNotificationAction(params) {
+    const { agentManager, registry, notificationId, action, replyText, logger } = params;
+    const entry = registry.get(notificationId);
+    if (!entry) {
+        return { ok: false, error: "unknown_notification" };
+    }
+    let response;
+    switch (action) {
+        case "approve":
+            response = { behavior: "allow" };
+            break;
+        case "deny":
+            response = { behavior: "deny" };
+            break;
+        case "reply": {
+            const message = replyText?.trim();
+            if (!message) {
+                return { ok: false, error: "missing_reply_text" };
+            }
+            response = { behavior: "deny", message };
+            break;
+        }
+    }
+    await respondToAgentPermission({
+        agentManager,
+        agentId: entry.agentId,
+        requestId: entry.requestId,
+        response,
+        logger,
+    });
+    registry.delete(notificationId);
+    return { ok: true };
+}
+//# sourceMappingURL=notification-action.js.map