@timurproko/a1 0.1.8-dev.0b6d8cc → 0.1.8-dev.21b95d6

package/dist/native/darwin-arm64/manifest.json

@@ -5,7 +5,7 @@
   "platform": "darwin",
   "architecture": "arm64",
   "capability": "unsupported",
-  "builtAt": "2026-08-25T08:02:28.988Z",
+  "builtAt": "2026-08-25T08:21:01.149Z",
   "artifact": {
     "filename": "process-guardian",
     "sha256": "7524bf568992517f50ed53196c861c5edeba0d7275633bb4735ab45bd5963a28",

package/dist/native/linux-x64/manifest.json

@@ -5,7 +5,7 @@
   "platform": "linux",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-08-25T08:02:31.153Z",
+  "builtAt": "2026-08-25T08:20:57.618Z",
   "artifact": {
     "filename": "process-guardian",
     "sha256": "29e22fe29de2828982bc67ef418c4adcaab1490281477b7bea592ec6fe621bcd",

package/dist/native/win32-x64/manifest.json

@@ -5,10 +5,10 @@
   "platform": "win32",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-08-25T08:02:58.479Z",
+  "builtAt": "2026-08-25T08:21:59.118Z",
   "artifact": {
     "filename": "process-guardian.exe",
-    "sha256": "fdbde2408643ffb897f5107d96ed40e8c8467505ef7daa64f86f9c2497c304ca",
+    "sha256": "82d4ad108c0e73f59b8bca207c751a7822e21045895c1453296fff6b649042ea",
     "size": 172544
   },
   "provenance": {

package/dist/src/foundation/pi-engine-adapter/adapter.js

@@ -1476,14 +1476,16 @@ export class PiEngineAdapter {
                 this.#upsertMessageBlock(event.message, "live");
                 return;
             case "message_update": {
-                const block = this.#upsertMessageBlock(event.message, "live");
-                if (block && isRecord(event.assistantMessageEvent) && typeof event.assistantMessageEvent.delta === "string") {
-                    this.#upsertTranscriptBlock({
-                        ...block,
-                        text: block.text.endsWith(event.assistantMessageEvent.delta)
-                            ? block.text
-                            : `${block.text}${event.assistantMessageEvent.delta}`,
-                    });
+                const delta = isRecord(event.assistantMessageEvent) && typeof event.assistantMessageEvent.delta === "string"
+                    ? event.assistantMessageEvent.delta
+                    : undefined;
+                // The delta is folded in before the block is stored, so a chunk is one update to
+                // one block rather than a store without the delta followed by a store with it.
+                const blocks = this.#messageBlocks(event.message, "live", this.#transcript.length);
+                for (const [index, block] of blocks.entries()) {
+                    this.#upsertTranscriptBlock(index === 0 && delta !== undefined && !block.text.endsWith(delta)
+                        ? { ...block, text: `${block.text}${delta}` }
+                        : block);
                 }
                 return;
             }
@@ -1638,7 +1640,13 @@ export class PiEngineAdapter {
                 }
             }
         }
-        this.#setTranscript(blocks);
+        // An authoritative rebuild restates most of what is already there. Reusing the block
+        // that already says it keeps its revision, and with it the rows the shell rendered for
+        // it — otherwise every turn that ends re-renders the whole session.
+        this.#setTranscript(blocks.map(block => {
+            const existing = this.#transcriptBlock(block.id);
+            return existing !== undefined && sameBlockContent(existing, block) ? existing : block;
+        }));
     }
     #upsertMessageBlock(message, status) {
         const blocks = this.#messageBlocks(message, status, this.#transcript.length);
@@ -1815,8 +1823,14 @@ export class PiEngineAdapter {
     }
     #upsertTranscriptBlock(block) {
         const index = this.#transcriptIndex.get(block.id);
-        if (index !== undefined)
+        if (index !== undefined) {
+            const existing = this.#transcript[index];
+            // Nothing to tell the shell about a block that repeats itself, and keeping the
+            // revision keeps the rows it already rendered.
+            if (existing !== undefined && sameBlockContent(existing, block))
+                return;
             this.#transcript[index] = block;
+        }
         else {
             this.#transcriptIndex.set(block.id, this.#transcript.length);
             this.#transcript.push(block);
@@ -2388,6 +2402,36 @@ function compactResourceLabel(path) {
     const segments = path.replaceAll("\\", "/").split("/").filter(Boolean);
     return segments.at(-1) ?? path;
 }
+/**
+ * Whether two blocks say the same thing. A block that says what it already said is not a
+ * new revision: the shell renders a block once per revision, so bumping one it did not
+ * need re-renders it for nothing.
+ */
+function sameBlockContent(left, right) {
+    return left.kind === right.kind
+        && left.status === right.status
+        && left.title === right.title
+        && left.text === right.text
+        && sameValue(left.payload, right.payload);
+}
+function sameValue(left, right) {
+    if (left === right)
+        return true;
+    if (typeof left !== typeof right || left === null || right === null)
+        return false;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length)
+            return false;
+        return left.every((value, index) => sameValue(value, right[index]));
+    }
+    if (typeof left !== "object")
+        return false;
+    const leftKeys = Object.keys(left);
+    const rightRecord = right;
+    if (leftKeys.length !== Object.keys(rightRecord).length)
+        return false;
+    return leftKeys.every(key => Object.hasOwn(rightRecord, key) && sameValue(left[key], rightRecord[key]));
+}
 function textFromContent(content) {
     if (typeof content === "string")
         return content;

package/dist/src/foundation/pi-owned-ui-integration/session-shell.d.ts

@@ -39,6 +39,12 @@ export declare class OwnedUiSessionShellRoot implements PiTuiComponentPort {
         readonly onDequeue?: () => void;
     }, startup?: PiShellHeaderOptions, agentDir?: string, extensionRenderers?: PiShellExtensionRendererResolver);
     update(view: OwnedUiSessionViewModel): void;
+    /**
+     * Applies one block: its component is created or updated in place and the order grows
+     * only when the block is new. A streamed chunk costs one component update rather than a
+     * walk of the whole transcript.
+     */
+    applyTranscriptBlock(block: OwnedUiSessionViewModel["transcript"][number]): void;
     render(width: number): readonly string[];
     layoutRoot(): PiTuiLayoutNode;
     transcriptComponent(id: string): PiShellTranscriptComponentPort | undefined;

package/dist/src/foundation/pi-owned-ui-integration/session-shell.js

@@ -71,6 +71,25 @@ export class OwnedUiSessionShellRoot {
         this.editor.setThinkingLevel(view.thinkingLevel);
         this.invalidate();
     }
+    /**
+     * Applies one block: its component is created or updated in place and the order grows
+     * only when the block is new. A streamed chunk costs one component update rather than a
+     * walk of the whole transcript.
+     */
+    applyTranscriptBlock(block) {
+        this.#blocksById.set(block.id, block);
+        const component = this.#transcript.get(block.id);
+        if (component === undefined) {
+            const created = createPiShellTranscriptComponent(block, this.#cwd, this.#extensionRenderers);
+            created.setExpanded(this.#toolsExpanded);
+            this.#transcript.set(block.id, created);
+            this.#transcriptOrder.push(block.id);
+        }
+        else if (component.revision !== block.revision) {
+            component.update(block);
+        }
+        this.invalidate();
+    }
     render(width) {
         const queued = this.#view.editor.queuedSubmissions.length === 0 ? [] : this.#queued.render(width);
         return [
@@ -794,9 +813,12 @@ export class OwnedUiSessionShell {
         });
         this.root.editor.setAutocompleteCommands(this.backend.workflowAutocompleteCommands());
         this.#unsubscribe = this.backend.onEvent(event => {
-            // One view read per event: the model is built by the backend, and building it
-            // twice per streamed chunk is what made a long session cost more per chunk.
-            const view = this.#syncView();
+            // A streamed chunk names one block, and touching only that block is what keeps the
+            // cost of a chunk the same in a long session as in a new one. Everything else
+            // resynchronizes the view, which is cheap next to re-reading the transcript.
+            const view = event.type === "transcript-block" && this.#sessionGeneration === this.backend.sessionGeneration
+                ? this.#syncBlock(event.block)
+                : this.#syncView();
             if (view.lifecycle === "ready" && this.#compactionQueue.length > 0)
                 void this.#flushCompactionQueue();
             if (event.type === "session-lifecycle" && event.lifecycle === "stopped")
@@ -1415,6 +1437,18 @@ export class OwnedUiSessionShell {
         this.#extensionBridge.dispose();
         await this.runtime.dispose();
     }
+    /**
+     * Applies one transcript block without re-reading the session. The listeners still hear
+     * the view they would have heard, so nothing downstream can tell the difference.
+     */
+    #syncBlock(block) {
+        this.root.applyTranscriptBlock(block);
+        this.runtime.requestRender();
+        const view = this.view();
+        for (const listener of this.#listeners)
+            listener(view);
+        return view;
+    }
     #syncView() {
         const view = this.view();
         if (this.backend.sessionGeneration !== this.#sessionGeneration) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timurproko/a1",
-  "version": "0.1.8-dev.0b6d8cc",
+  "version": "0.1.8-dev.21b95d6",
   "description": "Standalone terminal workspace for supervised native and managed agents",
   "type": "module",
   "packageManager": "npm@11.13.0",