@springbrand/agent-runtime 0.3.0-alpha.17 → 0.3.0-alpha.19

package/src/submission/finalization.ts

@@ -13,12 +13,14 @@ import type { SteerRepository } from "./steer-repository";
 
 /** Commits the Submission outcome and human/Host facts after accepted steering is preserved. */
 export class SubmissionFinalizer {
+  /** User-stop markers appended after their terminal commit; every `finish()` of that Turn awaits it. */
+  private readonly stopMarkers = new Map<string, Promise<unknown>>();
   constructor(private readonly options: {
     submissions: SubmissionRepository;
     steers: SteerRepository;
     messageUi: MessageUiRepository;
     transaction<T>(run: () => T): T;
-    conversation: Pick<ConversationHistory, "append" | "storedMessages">;
+    conversation: Pick<ConversationHistory, "append" | "appendTurnAbortedMarker" | "storedMessages">;
     decisions: Pick<HarnessHumanDecisions, "cancelForSubmission">;
     events: Pick<RuntimeTurnEvents, "submissionTerminal">;
     telemetry: Pick<RuntimeTelemetryCoordinator, "capture">;
@@ -34,7 +36,12 @@ export class SubmissionFinalizer {
     message?: string,
   ): Promise<StoredSubmission> {
     const initial = this.read(submissionId);
-    if (isTerminalSubmissionStatus(initial.status)) return initial;
+    if (isTerminalSubmissionStatus(initial.status)) {
+      // A stop RPC and the ending harness finish the same Turn; whichever loses
+      // still waits for the stop marker, so its history broadcast carries it.
+      await this.stopMarkers.get(submissionId);
+      return initial;
+    }
     const aborted = Boolean(initial.abortReason) || outcome === "aborted";
     if (aborted) await this.options.releaseAbortedHarness();
     await finishPendingSteers({
@@ -53,7 +60,13 @@ export class SubmissionFinalizer {
     const output = (await this.options.conversation.storedMessages())
       .filter((entry) => entry.submissionId === submissionId && entry.message.role === "assistant")
       .at(-1)?.message;
-    return this.commit(submissionId, outcome, message, output?.role === "assistant" ? output : undefined);
+    const completed = this.commit(submissionId, outcome, message, output?.role === "assistant" ? output : undefined);
+    const marker = this.stopMarkers.get(submissionId);
+    if (marker) {
+      await marker;
+      this.stopMarkers.delete(submissionId);
+    }
+    return completed;
   }
 
   /** Shares atomic terminal facts with an admitted handoff cancelled before execution. */
@@ -63,7 +76,8 @@ export class SubmissionFinalizer {
     message?: string,
     output?: AssistantMessage,
   ): StoredSubmission {
-    return this.options.transaction(() => {
+    let stoppedByUser = false;
+    const completed = this.options.transaction(() => {
       // Host admission and history reads can await while an explicit stop wins.
       const latest = this.read(submissionId);
       if (isTerminalSubmissionStatus(latest.status)) return latest;
@@ -79,6 +93,10 @@ export class SubmissionFinalizer {
       const status = effectiveOutcome === "succeeded" ? "completed" : effectiveOutcome === "aborted" ? "aborted" : "error";
       this.options.submissions.updateTerminal(submissionId, status, reason, Date.now());
       const completed = this.read(submissionId);
+      stoppedByUser = effectiveOutcome === "aborted" && reason === USER_STOP_REASON;
+      if (stoppedByUser && completed.completedAt === null) {
+        throw new Error(`Aborted SpringBrand submission has no completion time: ${submissionId}`);
+      }
       this.options.events.submissionTerminal(completed);
       this.options.telemetry.capture("turnFinished", {
         submissionId,
@@ -90,6 +108,20 @@ export class SubmissionFinalizer {
       });
       return completed;
     });
+    if (stoppedByUser) this.appendStopMarker(submissionId, completed.completedAt!);
+    return completed;
+  }
+
+  /**
+   * The browser projects `interruptedByUser` from this marker and the next model request sees it as user context.
+   * Pi history writes are async, so the marker follows the synchronous terminal commit.
+   */
+  private appendStopMarker(submissionId: string, completedAt: number): void {
+    const marker = this.options.conversation.appendTurnAbortedMarker(submissionId, completedAt).catch((error: unknown) => {
+      console.warn("[runtime-stop-marker:failed]", submissionId, error instanceof Error ? error.message : String(error));
+    });
+    this.stopMarkers.set(submissionId, marker);
+    this.options.waitUntil(marker);
   }
 
   private read(submissionId: string): StoredSubmission {

package/src/tools/runtime/compiler.ts

@@ -168,8 +168,15 @@ export function compileHarnessTools(
       ...(candidate.deferLoading ? { deferLoading: true as const } : {}),
       async execute(args, api, context) {
         const toolCallId = api.callId;
+        // AgentTool progress is a replacing snapshot (web_search sends its accumulated text), but Pi output only
+        // appends and has no replace operation: append a grown snapshot's suffix, and start a new line otherwise.
+        let shown = "";
         const onUpdate = (update: AgentToolResult<unknown>) => {
-          for (const part of update.content) if (part.type === "text") api.output(part.text);
+          const text = update.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("");
+          if (text && text !== shown) {
+            api.output(text.startsWith(shown) ? text.slice(shown.length) : shown ? `\n${text}` : text);
+            shown = text;
+          }
           if (update.details !== undefined) void api.details(update.details, context).catch(() => {});
         };
         const signal = context.abortSignal ?? new AbortController().signal;