@evandu/super-pi 0.1.148 → 0.1.149

package/dist/client/.super-pi-client-sources.json

@@ -35,5 +35,5 @@
     "src/client/types.ts": "7c06189b32890009d28a371a64d9f29161c14a349a5b399d51d1314d38fa27ac",
     "src/client/vite-env.d.ts": "65996936fbb042915f7b74a200fcdde7e410f32a669b1ab9597cfaa4b0faddb5"
   },
-  "recordedAt": "2026-11-01T14:41:49.801Z"
+  "recordedAt": "2026-11-01T14:53:57.934Z"
 }

package/dist/server/application/session-orchestrator-service.d.ts

@@ -110,16 +110,27 @@ export declare class SessionOrchestratorService {
      */
     private readonly lengthContinuations;
     /**
-     * THE CHILDREN THAT HAVE ALREADY REPORTED THEIR OWN RESULT TO THEIR PARENT.
+     * THE CHILDREN THAT HAVE ALREADY REPORTED THEIR OWN RESULT TO THEIR PARENT, AND WHEN.
      *
      * A child can report explicitly - the `report` action - and that report is the child's own
      * statement of what it did. When the child's turn then ends, the automatic completion report
      * would deliver the same thing a second time, so the automatic path steps aside for a child that
-     * is in this set.
+     * is in this map.
      *
      * The entry is added only by a TERMINAL report (`completed` / `failed`), because an interim
      * update is not the child's final word: the task is still running, and the parent will want to
      * hear how it ended.
+     *
+     * WHY THE MAP HOLDS A TIMESTAMP AND NOT A FLAG. A flag says "this child reported", and that is
+     * not the same question as "this child reported ABOUT THE TURN THAT JUST ENDED". A flag stays
+     * true for the rest of the child's life, so it silences every automatic report the child ever
+     * produces again: the parent gives the same child a second task, the child finishes, and the
+     * result is swallowed because of a report the parent received about the FIRST task. The parent
+     * waits for a result that was written and never arrives, and nothing in the transcript says why.
+     *
+     * The timestamp answers the real question: the report was made INSIDE this turn, so it speaks for
+     * this turn. A report made before the turn started speaks for an earlier one, and this turn's
+     * result is still its own.
      */
     private readonly reportedChildren;
     constructor(store: Store, conversationService: ConversationService, runService: RunService, ledger: SessionLedger, broadcaster?: EventBroadcaster | undefined, watchdog?: SessionWatchdog);

package/dist/server/application/session-orchestrator-service.js

@@ -39,18 +39,29 @@ export class SessionOrchestratorService {
      */
     lengthContinuations = new Map();
     /**
-     * THE CHILDREN THAT HAVE ALREADY REPORTED THEIR OWN RESULT TO THEIR PARENT.
+     * THE CHILDREN THAT HAVE ALREADY REPORTED THEIR OWN RESULT TO THEIR PARENT, AND WHEN.
      *
      * A child can report explicitly - the `report` action - and that report is the child's own
      * statement of what it did. When the child's turn then ends, the automatic completion report
      * would deliver the same thing a second time, so the automatic path steps aside for a child that
-     * is in this set.
+     * is in this map.
      *
      * The entry is added only by a TERMINAL report (`completed` / `failed`), because an interim
      * update is not the child's final word: the task is still running, and the parent will want to
      * hear how it ended.
+     *
+     * WHY THE MAP HOLDS A TIMESTAMP AND NOT A FLAG. A flag says "this child reported", and that is
+     * not the same question as "this child reported ABOUT THE TURN THAT JUST ENDED". A flag stays
+     * true for the rest of the child's life, so it silences every automatic report the child ever
+     * produces again: the parent gives the same child a second task, the child finishes, and the
+     * result is swallowed because of a report the parent received about the FIRST task. The parent
+     * waits for a result that was written and never arrives, and nothing in the transcript says why.
+     *
+     * The timestamp answers the real question: the report was made INSIDE this turn, so it speaks for
+     * this turn. A report made before the turn started speaks for an earlier one, and this turn's
+     * result is still its own.
      */
-    reportedChildren = new Set();
+    reportedChildren = new Map();
     constructor(store, conversationService, runService, ledger, broadcaster, watchdog) {
         this.store = store;
         this.conversationService = conversationService;
@@ -180,6 +191,11 @@ export class SessionOrchestratorService {
         // writes the words under the reader's own name - so the child's transcript showed an
         // instruction the reader never typed, wearing the reader's avatar, and a reader who looked at
         // the child session saw their own name on somebody else's order.
+        //
+        // THE TURN'S START IS RECORDED HERE, because the question "did this child already report THIS
+        // turn?" is answered by comparing the report's time against it. A report made inside the turn
+        // speaks for the turn; a report made before it speaks for an earlier one.
+        const turnStartedAt = Date.now();
         const runPromise = this.runService.enqueueAndRunAsAgent(conversationId, content);
         const completion = (async () => {
             let failure;
@@ -238,9 +254,13 @@ export class SessionOrchestratorService {
                     // is what it produced"; the explicit report says "the child is telling its parent something
                     // now", and can be called at any point in the task's life.
                     const turnEnded = current?.status === "completed" || current?.status === "failed";
-                    // A CHILD THAT REPORTED ITSELF IS NOT REPORTED TWICE. The explicit terminal report is the
-                    // child's own statement of what it did, so the automatic completion steps aside for it.
-                    const alreadyReported = this.reportedChildren.has(conversationId);
+                    // A CHILD THAT REPORTED ITSELF IS NOT REPORTED TWICE - BUT ONLY FOR THE TURN IT REPORTED.
+                    // The explicit terminal report is the child's own statement of what it did, so the
+                    // automatic completion steps aside for it - when the report was made inside THIS turn.
+                    // A report from an earlier turn says nothing about this one's result, and silencing this
+                    // one because of that would swallow a result the parent is still waiting for.
+                    const reportedAt = this.reportedChildren.get(conversationId);
+                    const alreadyReported = reportedAt !== undefined && reportedAt >= turnStartedAt;
                     if (turnEnded && !alreadyReported) {
                         await this.runService.enqueueSessionResult({
                             conversationId,
@@ -260,6 +280,16 @@ export class SessionOrchestratorService {
                 // turn an already-finished child turn into a second failure.
                 console.warn(`Super Pi: session result callback failed for ${conversationId}:`, error instanceof Error ? error.message : String(error));
             }
+            finally {
+                // THE RECORD IS SPENT BY THE TURN IT SPOKE FOR. Whatever it was about, that turn is over.
+                //
+                // A record left behind would be harmless - the timestamp comparison already keeps it from
+                // silencing a later turn - but it would keep saying "this child reported" to every future
+                // reader of this code, and the next thing that consults it would have to re-derive the
+                // timestamp rule. Dropping it here keeps one rule in one place: a report belongs to the
+                // turn that was running when it was made.
+                this.reportedChildren.delete(conversationId);
+            }
             if (failure !== undefined) {
                 console.warn(`Super Pi: dispatch failed for conversation ${conversationId}:`, failure instanceof Error ? failure.message : String(failure));
                 this.ledger.update(conversationId, { status: "failed" });
@@ -391,7 +421,10 @@ export class SessionOrchestratorService {
         // does not silence the automatic report: the child is still working, and the parent will want
         // to hear how the task ended.
         if (status === "completed" || status === "failed") {
-            this.reportedChildren.add(childConversationId);
+            // THE TIME OF THE REPORT IS THE PART THAT MATTERS. It is what tells the completion path
+            // whether this report spoke for the turn that is ending or for an earlier one, and it is
+            // stamped here - where the report is made - rather than where it is looked up later.
+            this.reportedChildren.set(childConversationId, Date.now());
             await this.watchdog.cancel(childConversationId);
         }
         else {

package/package.json

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