@evandu/super-pi 0.1.63 → 0.1.65

package/dist/server/application/extension-ui-service.d.ts

@@ -3,6 +3,14 @@ import type { ExtensionUiAnswer, ExtensionUiCloseReason } from "../types.js";
 import type { EventBroadcaster } from "../server-context.js";
 /**
  * Service managing extension UI interactive prompts between Pi / subagents and connected clients.
+ *
+ * NO SAFETY-NET TIMEOUT. A question that nobody answers stays in the map until the run it belongs to
+ * is stopped, the conversation is reset, or the server shuts down - the run-level teardown is the
+ * only path that ever settles an unanswered ask, and it is the right path: a model waiting on a
+ * human for ten minutes is not a model that has decided to give up, and resolving the ask with a
+ * fabricated "cancelled" answer was the source of 「未定义行为」 the user reported - the model
+ * accepted the cancel and continued from a state that was not the state the person was supposed to
+ * produce. A living, unanswered question is honest; a timed-out one is fiction.
  */
 export declare class ExtensionUiService {
     private readonly broadcaster;

package/dist/server/application/extension-ui-service.js

@@ -1,16 +1,13 @@
-/**
- * Safety net for questions Pi declared NO timeout for. The runtime races every blocking ask against the
- * run's abort and exit, but the losing `ask` promise is simply abandoned there - and for a detached
- * sub-agent run on an idle conversation nothing later cleans the entry up, so without a net it would sit
- * in the map forever with a question card the browser never sees close. The net settles such a question
- * as CANCELLED - never a default answer, per the design rule that a missing answer must not look like a
- * human decision - and broadcasts `extension.ui.closed` so the card disappears with a stated reason.
- * Generous, because a live run's question may legitimately wait on a slow human; this only bounds the
- * case where nothing can ever answer it.
- */
-const ASK_SAFETY_TIMEOUT_MS = 10 * 60 * 1000;
 /**
  * Service managing extension UI interactive prompts between Pi / subagents and connected clients.
+ *
+ * NO SAFETY-NET TIMEOUT. A question that nobody answers stays in the map until the run it belongs to
+ * is stopped, the conversation is reset, or the server shuts down - the run-level teardown is the
+ * only path that ever settles an unanswered ask, and it is the right path: a model waiting on a
+ * human for ten minutes is not a model that has decided to give up, and resolving the ask with a
+ * fabricated "cancelled" answer was the source of 「未定义行为」 the user reported - the model
+ * accepted the cancel and continued from a state that was not the state the person was supposed to
+ * produce. A living, unanswered question is honest; a timed-out one is fiction.
  */
 export class ExtensionUiService {
     broadcaster;
@@ -70,17 +67,16 @@ export class ExtensionUiService {
             ask: (request) => new Promise((resolve) => {
                 const shown = scoped(request);
                 const key = this.uiKey(conversationId, shown.requestId);
+                // Only the Pi-declared `timeoutMs` is honoured. There is no safety net when Pi did not set
+                // one: a question Pi chose to leave open is a question the model is waiting on, and a
+                // fabricated cancel would be the model continuing on a false premise. The run-level
+                // teardown (stop / abort / shutdown) is the path that closes an unanswered ask.
                 const pending = { conversationId, request: shown, resolve };
                 if (shown.timeoutMs !== undefined) {
                     pending.timer = setTimeout(() => {
                         this.settleUi(key, { cancelled: true }, "timeout");
                     }, shown.timeoutMs);
                 }
-                else {
-                    pending.timer = setTimeout(() => {
-                        this.settleUi(key, { cancelled: true }, "expired");
-                    }, ASK_SAFETY_TIMEOUT_MS);
-                }
                 this.pendingUi.set(key, pending);
                 this.broadcaster.broadcast({ type: "extension.ui", conversationId, request: shown });
             }),

package/dist/server/application/run-service.js

@@ -173,17 +173,22 @@ export class RunService {
             throw new Error("这个会话里没有正在等待回答的 question 工具调用");
         const { messageId, index } = found;
         return new Promise((resolve, reject) => {
-            const finish = (settle) => { clearInterval(poll); clearTimeout(deadline); settle(); };
+            // No timeout. The promise resolves when the question is answered, rejects when it is cancelled
+            // (the only honest "I will not answer" state - resolving with a default would be the model
+            // continuing from a question that was never decided). The run-level teardown (stop / abort /
+            // shutdown) clears the underlying ask and the client settles it as cancelled, which lands here
+            // and rejects. A question that is simply unanswered waits indefinitely.
             const poll = setInterval(() => {
                 const current = this.store.snapshot().conversations.find((item) => item.id === conversationId)?.messages.find((item) => item.id === messageId)?.toolCalls?.[index]?.question;
-                if (current?.status === "answered")
-                    finish(() => resolve(answerPayload(current)));
-                // CANCELLED IS NOT AN ANSWER. Rejecting is what makes the tool call fail, which is what stops the
-                // run; resolving here would let the model carry on from a question the person refused to answer.
-                else if (current?.status === "cancelled")
-                    finish(() => reject(new Error("用户没有回答这个问题")));
+                if (current?.status === "answered") {
+                    clearInterval(poll);
+                    resolve(answerPayload(current));
+                }
+                else if (current?.status === "cancelled") {
+                    clearInterval(poll);
+                    reject(new Error("用户没有回答这个问题"));
+                }
             }, 250);
-            const deadline = setTimeout(() => finish(() => reject(new Error("等待回答超时"))), 30 * 60 * 1000);
             // WHAT GOES BACK TO THE MODEL IS WRITTEN FOR THE MODEL. The answers pair to their questions by id,
             // which is what stops a person answering the second of two being recorded against the first - but an
             // id is a UUID, and a model handed `{answers:[{id:"671b0f0b-…", selected:["发"]}]}` has to guess at

package/dist/server/http-server.js

@@ -382,16 +382,14 @@ export function createHttpServer(options) {
                 json(403, { error: result.message });
                 return;
             }
-            // Validate cwd is a known workspace. Path comparison is normalized so Windows case
-            // differences or trailing separators do not produce a false "unknown workspace" failure
-            // when the extension hands back the same directory the server handed to it at spawn.
-            const normalized = (value) => value.replace(/[\\/]+/g, "/").replace(/\/+$/, "").toLowerCase();
-            const normalizedCwd = normalized(cwd);
-            const workspace = store.snapshot().workspaces.find((w) => normalized(w.path) === normalizedCwd);
-            if (!workspace) {
-                json(400, { error: `cwd is not a known workspace: ${cwd} (known: ${store.snapshot().workspaces.map((w) => w.path).join(" | ")})` });
-                return;
-            }
+            // The `cwd` here is the directory the Pi child was launched in - which is the conversation's
+            // workspace, already authenticated by the per-conversation capability check above. Validating it
+            // against the workspace list looked cheap, but Windows path normalization (8.3 short names, UNC
+            // prefixes, drive-letter case, separator styles) routinely produces the same path in two different
+            // strings and a strict equality check refused valid calls; a relaxed comparison is no longer
+            // providing a security boundary that the capability check is not already providing. The trust
+            // decision is the one above; this stays as a no-op.
+            void cwd;
             // Set up the background task record BEFORE spawning, so the UI shows it immediately
             const { randomUUID } = await import("node:crypto");
             const sessionId = `exec_${randomUUID()}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.63",
+  "version": "0.1.65",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",