pulseed 0.6.5 → 0.6.6

package/dist/interface/chat/chat-runner-event-bridge.js

@@ -1,17 +1,19 @@
 import { createAgentTimelineActivitySummary, projectAgentLoopEventToTimeline, } from "../../orchestrator/execution/agent-loop/agent-timeline.js";
-import { DIFF_ARTIFACT_MAX_LINES, formatIntentInput, formatToolActivity, previewActivityText, } from "./chat-runner-support.js";
+import { DIFF_ARTIFACT_MAX_LINES, formatToolActivity, previewActivityText, } from "./chat-runner-support.js";
 import { classifyFailureRecovery, classifyFailureRecoveryWithFallback, formatLifecycleFailureMessage, } from "./failure-recovery.js";
 import { redactSetupSecrets, redactSetupSecretsDeep } from "./setup-secret-intake.js";
-import { shouldRenderJapanese } from "./turn-language.js";
 import { createOperationProgressItem, operationProgressFromAgentActivitySummary, } from "./operation-progress.js";
+import { createUserVisibleSeedyTurnPresence, } from "./seedy-turn-presence.js";
 import { createTextUserInput } from "./user-input.js";
 import { createTurnStartOperation } from "./turn-protocol.js";
+const WAITING_HEARTBEAT_STALE_MS = 30_000;
 export class ChatRunnerEventBridge {
     onEventGetter;
     activeTurn = null;
     timelineActivityItemsByRun = new Map();
     eventRecorder = null;
     eventRecorderQueue = Promise.resolve();
+    waitingHeartbeatTimer = null;
     constructor(onEventGetter) {
         this.onEventGetter = onEventGetter;
     }
@@ -21,6 +23,18 @@ export class ChatRunnerEventBridge {
     getActiveTurn() {
         return this.activeTurn;
     }
+    getActiveSeedyPresence() {
+        return this.activeTurn?.seedyPresence ?? null;
+    }
+    hasRuntimeEvidenceForTurn(context) {
+        return this.getRuntimeEvidenceRefsForTurn(context).length > 0;
+    }
+    getRuntimeEvidenceRefsForTurn(context) {
+        const activeTurn = this.activeTurn;
+        if (!activeTurn || activeTurn.context.turnId !== context.turnId)
+            return [];
+        return activeTurn.runtimeEvidenceRefs;
+    }
     setEventRecorder(recorder) {
         this.eventRecorder = recorder;
     }
@@ -34,9 +48,15 @@ export class ChatRunnerEventBridge {
         };
     }
     eventBase(context) {
-        return { ...context, createdAt: new Date().toISOString() };
+        return {
+            runId: context.runId,
+            turnId: context.turnId,
+            ...(context.languageHint ? { languageHint: context.languageHint } : {}),
+            createdAt: new Date().toISOString(),
+        };
     }
     beginActiveTurn(context, cwd) {
+        this.clearWaitingHeartbeatTimer();
         let resolveFinished = () => { };
         const finished = new Promise((resolve) => {
             resolveFinished = resolve;
@@ -49,6 +69,7 @@ export class ChatRunnerEventBridge {
             finished,
             resolveFinished,
             recentEvents: [],
+            runtimeEvidenceRefs: [],
             recentFailureSignals: [],
             interruptRequested: false,
         };
@@ -59,6 +80,7 @@ export class ChatRunnerEventBridge {
         const activeTurn = this.activeTurn;
         if (!activeTurn || activeTurn.context.runId !== context.runId)
             return;
+        this.clearWaitingHeartbeatTimer();
         activeTurn.resolveFinished();
         this.activeTurn = null;
         this.timelineActivityItemsByRun.delete(context.runId);
@@ -86,27 +108,34 @@ export class ChatRunnerEventBridge {
             }),
             ...this.eventBase(context),
         });
-        this.emitEvent({
-            type: "assistant_final",
-            text: output,
-            persisted: false,
-            ...this.eventBase(context),
-        });
-        const elapsed_ms = Date.now() - start;
-        this.emitEvent({
-            type: "lifecycle_end",
-            status: success ? "completed" : "error",
-            elapsedMs: elapsed_ms,
-            persisted: false,
-            ...this.eventBase(context),
-        });
         const shouldFinishActiveTurn = options.finishActiveTurn ?? options.operation?.kind !== "TurnSteer";
+        const elapsed_ms = Date.now() - start;
         if (shouldFinishActiveTurn) {
+            this.emitEvent({
+                type: "assistant_final",
+                text: output,
+                persisted: false,
+                ...this.eventBase(context),
+            });
+            this.emitSeedyPresence(success ? "complete" : "blocked", context, {
+                subject: success ? "Response complete" : "Turn stopped",
+                reason: success
+                    ? "The turn finished and the final response is ready."
+                    : "The turn stopped before completing successfully.",
+                expectedNext: success ? "final" : "user_input",
+            });
+            this.emitEvent({
+                type: "lifecycle_end",
+                status: success ? "completed" : "error",
+                elapsedMs: elapsed_ms,
+                persisted: false,
+                ...this.eventBase(context),
+            });
             this.finishActiveTurn(context);
         }
         return { success, output, elapsed_ms };
     }
-    createAgentLoopEventSink(eventContext) {
+    createAgentLoopEventSink(eventContext, assistantBuffer, options = {}) {
         return {
             emit: async (event) => {
                 const timelineItem = projectAgentLoopEventToTimeline(event);
@@ -168,8 +197,17 @@ export class ChatRunnerEventBridge {
                     });
                     return;
                 }
-                if (event.type === "assistant_message" && event.phase === "commentary" && event.contentPreview) {
-                    this.emitActivity("commentary", previewActivityText(event.contentPreview, 120), eventContext, `commentary:${event.eventId}`);
+                if (event.type === "assistant_message" && event.contentPreview) {
+                    if (event.phase === "commentary") {
+                        this.emitActivity("commentary", previewActivityText(event.contentPreview, 120), eventContext, `commentary:${event.eventId}`);
+                        return;
+                    }
+                    const shouldStreamFinalCandidate = typeof options.streamFinalCandidate === "function"
+                        ? options.streamFinalCandidate()
+                        : options.streamFinalCandidate === true;
+                    if (shouldStreamFinalCandidate && assistantBuffer) {
+                        this.pushAssistantSnapshot(event.content ?? event.contentPreview, assistantBuffer, eventContext);
+                    }
                     return;
                 }
                 if (event.type === "plan_update") {
@@ -188,6 +226,13 @@ export class ChatRunnerEventBridge {
                     return;
                 }
                 if (event.type === "approval_request") {
+                    this.emitSeedyPresence("waiting", eventContext, {
+                        importance: "action_required",
+                        subject: "Waiting for approval",
+                        reason: "A tool request needs approval before the turn can continue.",
+                        lastActivityLabel: event.reason,
+                        expectedNext: "approval",
+                    });
                     this.rememberActiveTurnFailureSignal(eventContext, {
                         kind: "approval",
                         status: "requested",
@@ -260,14 +305,62 @@ export class ChatRunnerEventBridge {
         };
     }
     emitEvent(event) {
+        if (event.type === "assistant_final") {
+            this.emitSeedyPresence("finalizing", event);
+        }
         void this.deliverEvent(event);
     }
     async emitEventAndFlush(event) {
+        if (event.type === "assistant_final") {
+            await this.emitSeedyPresenceAndFlush("finalizing", event);
+        }
         await this.deliverEvent(event);
     }
+    emitSeedyPresence(phase, eventContext, input = {}) {
+        void this.emitSeedyPresenceAndFlush(phase, eventContext, input);
+    }
+    async emitSeedyPresenceAndFlush(phase, eventContext, input = {}) {
+        const activeTurn = this.activeTurn?.context.turnId === eventContext.turnId
+            ? this.activeTurn
+            : null;
+        const previous = activeTurn?.seedyPresence;
+        const expectedNext = input.expectedNext ?? defaultExpectedNextForPresencePhase(phase);
+        if (previous?.phase === "complete" && phase !== "complete")
+            return;
+        if (previous?.phase === phase
+            && previous.expected_next === expectedNext
+            && (input.importance === undefined || previous.importance === input.importance))
+            return;
+        const now = new Date().toISOString();
+        const startedAt = previous?.started_at
+            ?? (activeTurn ? new Date(activeTurn.startedAt).toISOString() : now);
+        const presence = createUserVisibleSeedyTurnPresence({
+            turn_id: eventContext.turnId,
+            ...(input.ingressId ? { ingress_id: input.ingressId } : {}),
+            phase,
+            ...(input.importance ? { importance: input.importance } : {}),
+            subject: input.subject ?? defaultSubjectForPresencePhase(phase),
+            reason: input.reason ?? defaultReasonForPresencePhase(phase),
+            started_at: startedAt,
+            updated_at: now,
+            last_activity_at: input.lastActivityAt ?? now,
+            ...(input.lastActivityLabel ? { last_activity_label: input.lastActivityLabel } : {}),
+            expected_next: expectedNext,
+        });
+        if (activeTurn) {
+            activeTurn.seedyPresence = presence;
+            this.scheduleWaitingHeartbeat(activeTurn);
+        }
+        await this.deliverEvent({
+            type: "presence_update",
+            presence,
+            ...this.eventBase(eventContext),
+        });
+    }
     async deliverEvent(event) {
         const safeEvent = redactChatEvent(event);
         this.rememberActiveTurnEvent(safeEvent);
+        await this.touchActiveSeedyPresenceForEvent(safeEvent);
         this.enqueueRecordedEvent(safeEvent);
         try {
             await this.onEventGetter()?.(safeEvent);
@@ -353,57 +446,6 @@ export class ChatRunnerEventBridge {
             ...this.eventBase(eventContext),
         });
     }
-    emitIntent(input, selectedRoute, eventContext) {
-        const subject = formatIntentInput(input);
-        let nextStep = "resume the saved agent loop state before continuing.";
-        let reason = "resume needs the prior runtime context before any further action.";
-        if ((selectedRoute?.kind === "runtime_control" || selectedRoute?.kind === "runtime_control_blocked") && selectedRoute.intent) {
-            nextStep = `prepare the ${selectedRoute.intent.kind} runtime-control request.`;
-            reason = "runtime changes need an explicit operation plan and approval path.";
-        }
-        else if (selectedRoute?.kind === "configure") {
-            if (shouldRenderJapanese(eventContext.languageHint)) {
-                nextStep = "requested setup flow の設定ガイダンスを準備します。";
-                reason = "setup request は agent-loop 実行前に実行可能な設定手順を返す必要があります。";
-            }
-            else {
-                nextStep = "prepare configuration guidance for the requested setup flow.";
-                reason = "setup requests should return actionable configuration steps before any agent-loop execution.";
-            }
-        }
-        else if (selectedRoute?.kind === "assist") {
-            nextStep = "answer directly from the current conversation context.";
-            reason = "this request can be handled as assistance without resuming an agent loop.";
-        }
-        else if (selectedRoute?.kind === "clarify") {
-            nextStep = "ask for the missing detail needed to choose the right next action.";
-            reason = "the current request is ambiguous and needs clarification before execution.";
-        }
-        else if (selectedRoute?.kind === "agent_loop") {
-            nextStep = "gather workspace context, then let the agent loop inspect or change files with visible tool activity.";
-            reason = "this request may require multiple tool-backed steps.";
-        }
-        else if (selectedRoute?.kind === "tool_loop") {
-            nextStep = "call the model with the tool catalog, then execute selected tools with visible activity.";
-            reason = "the available tools are needed to answer from current project state.";
-        }
-        else if (selectedRoute?.kind === "adapter") {
-            nextStep = "prepare project context before handing the turn to the configured adapter.";
-            reason = "the adapter needs the current workspace context to act correctly.";
-        }
-        const message = [
-            shouldRenderJapanese(eventContext.languageHint)
-                ? `このリクエストは ${subject || "現在のリクエスト"} として扱います。`
-                : `I understand the request as ${subject || "the current request"}.`,
-            shouldRenderJapanese(eventContext.languageHint)
-                ? `次に ${nextStep}`
-                : `Next I will ${nextStep}`,
-            shouldRenderJapanese(eventContext.languageHint)
-                ? `理由: ${reason}`
-                : `This is needed because ${reason}`,
-        ].join("\n");
-        this.emitActivity("commentary", message, eventContext, "intent:first-step", false);
-    }
     emitCheckpoint(title, detail, eventContext, sourceKey) {
         const message = detail ? `${title}: ${detail}` : title;
         this.emitActivity("checkpoint", message, eventContext, `checkpoint:${sourceKey}`, false);
@@ -440,7 +482,26 @@ export class ChatRunnerEventBridge {
             ...this.eventBase(eventContext),
         });
     }
+    pushAssistantSnapshot(snapshot, assistantBuffer, eventContext) {
+        const safeSnapshot = redactSetupSecrets(snapshot);
+        if (!safeSnapshot || safeSnapshot === assistantBuffer.text)
+            return;
+        if (safeSnapshot.startsWith(assistantBuffer.text)) {
+            this.pushAssistantDelta(safeSnapshot.slice(assistantBuffer.text.length), assistantBuffer, eventContext);
+            return;
+        }
+        if (!assistantBuffer.text) {
+            this.pushAssistantDelta(safeSnapshot, assistantBuffer, eventContext);
+        }
+    }
     emitLifecycleEndEvent(status, elapsedMs, eventContext, persisted) {
+        this.emitSeedyPresence(status === "completed" ? "complete" : "blocked", eventContext, {
+            subject: status === "completed" ? "Response complete" : "Turn stopped",
+            reason: status === "completed"
+                ? "The turn finished and the final response is ready."
+                : "The turn stopped before completing successfully.",
+            expectedNext: status === "completed" ? "final" : "user_input",
+        });
         this.emitEvent({
             type: "lifecycle_end",
             status,
@@ -500,10 +561,17 @@ export class ChatRunnerEventBridge {
         const activeTurn = this.activeTurn;
         if (!activeTurn || activeTurn.context.turnId !== event.turnId)
             return;
+        const runtimeEvidenceRef = runtimeEvidenceRefForEvent(event);
+        if (runtimeEvidenceRef) {
+            activeTurn.runtimeEvidenceRefs = [...activeTurn.runtimeEvidenceRefs, runtimeEvidenceRef].slice(-20);
+        }
         let summary = null;
         if (event.type === "activity") {
             summary = previewActivityText(event.message, 140);
         }
+        else if (event.type === "presence_update") {
+            summary = `Presence: ${event.presence.phase}`;
+        }
         else if (event.type === "tool_start") {
             summary = `Started ${event.toolName}`;
         }
@@ -517,6 +585,76 @@ export class ChatRunnerEventBridge {
             return;
         activeTurn.recentEvents = [...activeTurn.recentEvents, summary].slice(-12);
     }
+    async touchActiveSeedyPresenceForEvent(event) {
+        const activeTurn = this.activeTurn;
+        if (!activeTurn || activeTurn.context.turnId !== event.turnId || event.type === "presence_update")
+            return;
+        if (!activeTurn.seedyPresence || isTerminalEvent(event))
+            return;
+        const lastActivityLabel = lastActivityLabelForEvent(event);
+        if (lastActivityLabel === null)
+            return;
+        const now = new Date().toISOString();
+        const resumedPresence = resumedPresenceForEvent(event, lastActivityLabel);
+        if (activeTurn.seedyPresence.phase === "waiting" && resumedPresence) {
+            await this.emitSeedyPresenceAndFlush(resumedPresence.phase, activeTurn.context, {
+                ...resumedPresence,
+                lastActivityAt: now,
+                lastActivityLabel,
+            });
+            return;
+        }
+        activeTurn.seedyPresence = {
+            ...activeTurn.seedyPresence,
+            updated_at: now,
+            last_activity_at: now,
+            ...(lastActivityLabel ? { last_activity_label: lastActivityLabel } : {}),
+        };
+        this.scheduleWaitingHeartbeat(activeTurn);
+    }
+    scheduleWaitingHeartbeat(activeTurn) {
+        this.clearWaitingHeartbeatTimer();
+        const presence = activeTurn.seedyPresence;
+        if (!presence || shouldSuppressWaitingHeartbeat(presence))
+            return;
+        const lastActivityAt = Date.parse(presence.last_activity_at ?? presence.updated_at);
+        if (!Number.isFinite(lastActivityAt))
+            return;
+        const delayMs = Math.max(0, WAITING_HEARTBEAT_STALE_MS - (Date.now() - lastActivityAt));
+        this.waitingHeartbeatTimer = setTimeout(() => {
+            this.waitingHeartbeatTimer = null;
+            this.emitWaitingHeartbeatIfStale(activeTurn);
+        }, delayMs);
+        this.waitingHeartbeatTimer.unref?.();
+    }
+    emitWaitingHeartbeatIfStale(activeTurn) {
+        if (this.activeTurn !== activeTurn)
+            return;
+        const presence = activeTurn.seedyPresence;
+        if (!presence || shouldSuppressWaitingHeartbeat(presence))
+            return;
+        const lastActivityAt = presence.last_activity_at ?? presence.updated_at;
+        const lastActivityMs = Date.parse(lastActivityAt);
+        if (!Number.isFinite(lastActivityMs))
+            return;
+        if (Date.now() - lastActivityMs < WAITING_HEARTBEAT_STALE_MS) {
+            return;
+        }
+        void this.emitSeedyPresenceAndFlush("waiting", activeTurn.context, {
+            importance: "status",
+            subject: presence.subject ?? "Still working",
+            reason: "No new visible activity has arrived recently, but the turn is still active.",
+            lastActivityAt,
+            lastActivityLabel: presence.last_activity_label ?? presence.subject,
+            expectedNext: presence.expected_next ?? "progress",
+        });
+    }
+    clearWaitingHeartbeatTimer() {
+        if (this.waitingHeartbeatTimer === null)
+            return;
+        clearTimeout(this.waitingHeartbeatTimer);
+        this.waitingHeartbeatTimer = null;
+    }
     parseAgentLoopPreview(preview) {
         try {
             const parsed = JSON.parse(preview);
@@ -533,4 +671,201 @@ export class ChatRunnerEventBridge {
 function redactChatEvent(event) {
     return redactSetupSecretsDeep(event);
 }
+function isTerminalEvent(event) {
+    return event.type === "assistant_final" ||
+        event.type === "surface_delivery" ||
+        event.type === "lifecycle_end" ||
+        event.type === "lifecycle_error";
+}
+function runtimeEvidenceRefForEvent(event) {
+    switch (event.type) {
+        case "tool_end":
+            return `tool_end:${event.toolName}:${event.toolCallId}:${event.success ? "success" : "failure"}`;
+        case "operation_progress":
+            return `operation_progress:${event.item.operation}:${event.item.kind}:${event.item.id}`;
+        case "agent_timeline":
+            return event.item.kind === "tool"
+                ? `agent_timeline:${event.item.kind}:${event.item.sourceEventId}`
+                : null;
+        default:
+            return null;
+    }
+}
+function shouldSuppressWaitingHeartbeat(presence) {
+    return presence.phase === "waiting"
+        || presence.phase === "blocked"
+        || presence.phase === "complete"
+        || presence.importance === "blocked"
+        || presence.importance === "action_required"
+        || presence.expected_next === "approval";
+}
+function lastActivityLabelForEvent(event) {
+    switch (event.type) {
+        case "operation_progress": {
+            const publicProgress = event.item.publicProgress;
+            if (!publicProgress || publicProgress.audience !== "user" || publicProgress.verbosity === "silent")
+                return null;
+            return publicProgress.lastActivityLabel ?? publicProgress.subject;
+        }
+        case "activity":
+            if (event.presentation?.gatewayNarration?.audience === "user") {
+                return event.presentation.gatewayNarration.lastActivityLabel
+                    ?? event.presentation.gatewayNarration.subject;
+            }
+            if (event.presentation?.gatewayProgress === "user")
+                return `${event.kind} update`;
+            return null;
+        case "tool_start":
+            return event.activityCategory ? `${event.activityCategory} started` : "tool activity started";
+        case "tool_update":
+            return event.status === "awaiting_approval"
+                ? "approval requested"
+                : event.activityCategory
+                    ? `${event.activityCategory} activity`
+                    : "tool activity";
+        case "tool_end":
+            return event.activityCategory ? `${event.activityCategory} finished` : "tool activity finished";
+        case "agent_timeline":
+            if (event.item.kind === "tool")
+                return "tool activity";
+            if (event.item.kind === "approval")
+                return "approval activity";
+            return null;
+        case "assistant_delta":
+            return "drafting the response";
+        case "lifecycle_start":
+        case "turn_steer":
+        case "assistant_final":
+        case "surface_delivery":
+        case "user_feedback":
+        case "presence_update":
+        case "lifecycle_end":
+        case "lifecycle_error":
+            return null;
+    }
+}
+function resumedPresenceForEvent(event, lastActivityLabel) {
+    switch (event.type) {
+        case "assistant_delta":
+            return {
+                phase: "finalizing",
+                subject: "Drafting response",
+                reason: "Visible response text resumed after a quiet period.",
+                expectedNext: "final",
+            };
+        case "tool_update":
+            if (event.status === "awaiting_approval") {
+                return {
+                    phase: "waiting",
+                    importance: "action_required",
+                    subject: "Waiting for approval",
+                    reason: "A tool request needs approval before the turn can continue.",
+                    expectedNext: "approval",
+                };
+            }
+            return resumedActingPresence(lastActivityLabel);
+        case "operation_progress": {
+            const publicProgress = event.item.publicProgress;
+            if (publicProgress?.audience === "user" && publicProgress.verbosity !== "silent") {
+                if (publicProgress.importance === "blocked" || publicProgress.phase === "blocked") {
+                    return {
+                        phase: "blocked",
+                        importance: "blocked",
+                        subject: publicProgress.subject,
+                        reason: publicProgress.reason ?? "The active turn is blocked.",
+                        expectedNext: "user_input",
+                    };
+                }
+                if (publicProgress.importance === "action_required") {
+                    return {
+                        phase: "waiting",
+                        importance: "action_required",
+                        subject: publicProgress.subject,
+                        reason: publicProgress.reason ?? "The active turn needs input before it can continue.",
+                        expectedNext: "approval",
+                    };
+                }
+            }
+            return resumedActingPresence(lastActivityLabel);
+        }
+        case "activity":
+        case "tool_start":
+        case "tool_end":
+        case "agent_timeline":
+            return resumedActingPresence(lastActivityLabel);
+        case "lifecycle_start":
+        case "turn_steer":
+        case "assistant_final":
+        case "surface_delivery":
+        case "user_feedback":
+        case "presence_update":
+        case "lifecycle_end":
+        case "lifecycle_error":
+            return null;
+    }
+}
+function resumedActingPresence(lastActivityLabel) {
+    return {
+        phase: "acting",
+        subject: lastActivityLabel,
+        reason: "Visible activity resumed after a quiet period.",
+        expectedNext: "progress",
+    };
+}
+function defaultExpectedNextForPresencePhase(phase) {
+    switch (phase) {
+        case "received":
+        case "orienting":
+        case "thinking":
+        case "acting":
+            return "progress";
+        case "waiting":
+            return "approval";
+        case "blocked":
+            return "user_input";
+        case "finalizing":
+        case "complete":
+            return "final";
+    }
+}
+function defaultSubjectForPresencePhase(phase) {
+    switch (phase) {
+        case "received":
+            return "Message received";
+        case "orienting":
+            return "Orienting";
+        case "thinking":
+            return "Working on the response";
+        case "acting":
+            return "Taking action";
+        case "waiting":
+            return "Waiting";
+        case "blocked":
+            return "Needs attention";
+        case "finalizing":
+            return "Completing response";
+        case "complete":
+            return "Response complete";
+    }
+}
+function defaultReasonForPresencePhase(phase) {
+    switch (phase) {
+        case "received":
+            return "PulSeed accepted the turn and is preparing the next step.";
+        case "orienting":
+            return "PulSeed is selecting the right route before any heavier work starts.";
+        case "thinking":
+            return "PulSeed has enough context to continue the turn.";
+        case "acting":
+            return "PulSeed is executing the selected route.";
+        case "waiting":
+            return "PulSeed is waiting for external input before continuing.";
+        case "blocked":
+            return "PulSeed stopped before it could produce a successful result.";
+        case "finalizing":
+            return "PulSeed is preparing the final response.";
+        case "complete":
+            return "PulSeed finished the turn.";
+    }
+}
 //# sourceMappingURL=chat-runner-event-bridge.js.map