@piagent/platform 1.5.3 → 1.5.5

package/packages/piagent-webui/dist/client/index.html

@@ -7,7 +7,7 @@
     <meta name="csp-nonce" content="__PIAGENT_CSP_NONCE__" />
     <meta name="piagent-webui-mode" content="__PIAGENT_WEBUI_MODE__" />
     <title>Piagent WebUI</title>
-    <script type="module" crossorigin src="/assets/index-DZg979Ht.js"></script>
+    <script type="module" crossorigin src="/assets/index-BZRFw1u6.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-BV-_03yl.css">
   </head>
   <body>

package/packages/piagent-webui/gateway/gateway-session-stream.ts

@@ -31,6 +31,8 @@ export class GatewaySessionStream {
   #truncated = false;
   #started = false;
   #startListeners: Array<() => void> = [];
+  #settled = false;
+  #settleListeners: Array<() => void> = [];
   readonly #toolRefs = new Map<string, string>();
 
   constructor(options: { sessionRef: string; operationRef: string; events: GatewayEventStore }) {
@@ -42,10 +44,18 @@ export class GatewaySessionStream {
     return new Promise((resolve) => this.#startListeners.push(resolve));
   }
 
+  settled(): Promise<void> {
+    if (this.#settled) return Promise.resolve();
+    return new Promise((resolve) => this.#settleListeners.push(resolve));
+  }
+
   observe(event: any): void {
     if (event?.type === "agent_start") {
       this.#started = true; for (const resolve of this.#startListeners.splice(0)) resolve(); return;
     }
+    if (event?.type === "agent_settled") {
+      this.#settled = true; for (const resolve of this.#settleListeners.splice(0)) resolve(); return;
+    }
     if (event?.type === "message_start" && event.message?.role === "assistant") {
       this.#messageRef = ref("message"); this.#buffer = ""; return;
     }

package/packages/piagent-webui/gateway/rpc-ui-context.ts

@@ -0,0 +1,28 @@
+import { GATEWAY_RUNTIME_UI_MARKER } from "../ownership/gateway-runtime-context.ts";
+
+export function rpcUiContext(): object {
+  const plain = (text: unknown): string => String(text ?? "");
+  const theme = Object.freeze({
+    fg: (_color: unknown, text: unknown) => plain(text),
+    bg: (_color: unknown, text: unknown) => plain(text),
+    bold: plain,
+    italic: plain,
+    underline: plain,
+    inverse: plain,
+    strikethrough: plain,
+    getFgAnsi: () => "",
+    getBgAnsi: () => "",
+    getColorMode: () => "truecolor",
+    getThinkingBorderColor: () => plain,
+    getBashModeBorderColor: () => plain
+  });
+  return new Proxy({}, {
+    get(_target, property) {
+      if (property === GATEWAY_RUNTIME_UI_MARKER) return true;
+      if (property === "theme") return theme;
+      if (property === "confirm") return () => new Promise<boolean>(() => undefined);
+      if (property === "select" || property === "input") return async () => undefined;
+      return () => undefined;
+    }
+  });
+}

package/packages/piagent-webui/gateway/session-operation-start.ts

@@ -0,0 +1,34 @@
+import { GatewaySessionStream } from "./gateway-session-stream.ts";
+
+const DEFERRED_OPERATION_START_GRACE_MS = 5_000;
+
+export async function waitForOperationStart(
+  stream: GatewaySessionStream,
+  prompt: Promise<void>
+): Promise<"prompt-owned" | "deferred"> {
+  const started = stream.started();
+  const first = await Promise.race([
+    started.then(() => ({ state: "started" as const })),
+    prompt.then(() => ({ state: "prompt-resolved" as const }),
+      (error: unknown) => ({ state: "prompt-rejected" as const, error }))
+  ]);
+  if (first.state === "started") return "prompt-owned";
+  if (first.state === "prompt-rejected") throw first.error;
+
+  // Extension commands such as `/workflow` launch their agent turn through
+  // `pi.sendUserMessage()`. The outer prompt resolves before that deferred turn
+  // emits `agent_start`, so retain ownership until the real operation appears.
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    await Promise.race([
+      started,
+      new Promise<never>((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error("session-operation-start-unobserved")),
+          DEFERRED_OPERATION_START_GRACE_MS);
+      })
+    ]);
+    return "deferred";
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}

package/packages/piagent-webui/gateway/session-runtime-supervisor.ts

@@ -11,9 +11,10 @@ import { isUserConversationSession, projectRefForCwd, sessionRefForPath } from "
 import { SessionLeaseStore, type SessionLeaseSnapshot } from "./session-lease-store.ts";
 import { GatewayEventStore } from "./gateway-events.ts";
 import { GatewaySessionStream } from "./gateway-session-stream.ts";
-import { GATEWAY_RUNTIME_UI_MARKER } from "../ownership/gateway-runtime-context.ts";
 import { preferAuthoritativePiagentGuard } from "./extension-authority.ts";
 import { executePermissionCommand, executeRuntimeCommand } from "./runtime-session-controls.ts";
+import { rpcUiContext } from "./rpc-ui-context.ts";
+import { waitForOperationStart } from "./session-operation-start.ts";
 
 const MAX_WARM_RUNTIMES = 10;
 
@@ -25,33 +26,6 @@ type ActiveRuntime = { runtime: RuntimeHandle; lease: SessionLeaseSnapshot; info
 type Projection = { sessionRevision: string; liveState: "offline" | "idle" | "running" | "paused" | "waiting-approval" | "uncertain" };
 type RuntimeCommandResult = Awaited<ReturnType<typeof executeRuntimeCommand>>;
 
-function rpcUiContext(): object {
-  const plain = (text: unknown): string => String(text ?? "");
-  const theme = Object.freeze({
-    fg: (_color: unknown, text: unknown) => plain(text),
-    bg: (_color: unknown, text: unknown) => plain(text),
-    bold: plain,
-    italic: plain,
-    underline: plain,
-    inverse: plain,
-    strikethrough: plain,
-    getFgAnsi: () => "",
-    getBgAnsi: () => "",
-    getColorMode: () => "truecolor",
-    getThinkingBorderColor: () => plain,
-    getBashModeBorderColor: () => plain
-  });
-  return new Proxy({}, {
-    get(_target, property) {
-      if (property === GATEWAY_RUNTIME_UI_MARKER) return true;
-      if (property === "theme") return theme;
-      if (property === "confirm") return () => new Promise<boolean>(() => undefined);
-      if (property === "select" || property === "input") return async () => undefined;
-      return () => undefined;
-    }
-  });
-}
-
 function productionRuntimeFactory(options: { host: any; agentDir: string; packageRoot: string; modelRuntime?: any }): RuntimeFactory {
   return async (info, _runtimeInstanceRef, sessionManager) => {
     const guard = path.join(options.packageRoot, "packages", "piagent-core", "extensions", "piagent-guard.ts");
@@ -305,12 +279,18 @@ export class SessionRuntimeSupervisor {
     let prompt: Promise<void>;
     try { prompt = session.prompt(payload.message, payload.images?.length ? { images: payload.images } : undefined); }
     catch (error) { await this.#finishOperation(sessionRef, operationRef, stream); throw error; }
-    active.completion = prompt.then(() => this.#finishOperation(sessionRef, operationRef, stream),
+    const started = waitForOperationStart(stream, prompt);
+    // A normal prompt resolves after the agent settles. A workflow extension
+    // command resolves before its nested agent turn starts. In both cases the
+    // canonical completion boundary is `agent_settled`, not the outer promise.
+    const lifecycle = started.then(async (mode) => {
+      if (mode === "deferred") await stream.settled();
+      else await Promise.race([stream.settled(), prompt]);
+    });
+    active.completion = lifecycle.then(() => this.#finishOperation(sessionRef, operationRef, stream),
       () => this.#finishOperation(sessionRef, operationRef, stream));
-    await Promise.race([
-      stream.started(),
-      prompt.then(() => { throw new Error("session-operation-start-unobserved"); }, (error: unknown) => { throw error; })
-    ]);
+    try { await started; }
+    catch (error) { await active.completion; throw error; }
     return { resultCode: "started", operationRef };
   }
 
@@ -318,6 +298,10 @@ export class SessionRuntimeSupervisor {
     const active = this.#active.get(sessionRef), session = active?.runtime.session;
     if (!active || !session || active.operationRef !== operationRef) throw new Error("session-operation-conflict");
     const completion = active.completion;
+    // Extension hooks do not receive the Agent abort signal while awaiting a
+    // human approval. Resolve the exact operation's broker promise first so a
+    // stop request can reach the host instead of waiting for approval expiry.
+    piApprovalBroker.cancelForOperation(active.info.cwd, active.info.id, operationRef);
     await session.abort();
     if (clearQueued) session.clearQueue();
     await completion;

package/scripts/piagent-dashboard.mjs

@@ -122,6 +122,17 @@ async function currentLaunchUrl() {
   return null;
 }
 
+async function waitForGatewayStopped(previous, timeoutMs = 8_000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const previousAlive = Boolean(previous && processAlive(previous.pid));
+    const liveUrl = await currentLaunchUrl();
+    if (!previousAlive && !liveUrl) return;
+    await new Promise((resolve) => setTimeout(resolve, 80));
+  }
+  throw new Error("gateway-restart-stop-timeout\nThe previous Gateway did not stop; restart refused to reuse the old process.");
+}
+
 async function ensureStarted() {
   const existing = await currentLaunchUrl();
   if (existing) return existing;
@@ -199,8 +210,9 @@ async function main() {
     return;
   }
   if (command === "restart") {
+    const previous = readGatewayDescriptor(gatewayProfileState(agentDir));
     try { await control("stop"); } catch { /* already stopped */ }
-    await new Promise((resolve) => setTimeout(resolve, 150));
+    await waitForGatewayStopped(previous);
     const launchUrl = await ensureStarted();
     output(json ? { state: "running", launchUrl } : launchUrl);
     openBrowser(launchUrl);