@astrosheep/keiyaku 4.5.21 → 4.5.23

package/build/src/akuma/providers/codex-app-server/events.js

@@ -338,12 +338,16 @@ function terminalResult(params, state) {
 }
 export function codexNotificationResult(notification, state, events) {
     const method = notification.method;
+    const params = codexObject(notification.params) ?? {};
+    const notificationThreadId = codexText(params.threadId);
+    if (state.threadId !== undefined && notificationThreadId !== undefined && notificationThreadId !== state.threadId) {
+        return undefined;
+    }
     if (!Object.hasOwn(CODEX_NOTIFICATION_DISPOSITIONS, method)) {
         events.emit(unknownEvent(method));
         return undefined;
     }
     const disposition = CODEX_NOTIFICATION_DISPOSITIONS[method];
-    const params = codexObject(notification.params) ?? {};
     switch (disposition) {
         case "drop":
             return undefined;

package/build/src/cli/render/akuma-activity.d.ts

@@ -26,8 +26,9 @@ type RowLayout = Readonly<{
     marker: (count: number) => string;
 }>;
 /**
- * Shared snapshot activity rendering. Full snapshots focus known tool evidence;
- * `latest` preserves compact callers' established newest-entry selection.
+ * Shared snapshot activity rendering. Full snapshots render the selected
+ * activity evidence; an idle snapshot is settled evidence. `latest` preserves
+ * compact callers' established newest-entry selection.
  */
 export declare function snapshotActivityLines(snapshot: RenderedSnapshot, context: TextRenderContext, selection?: Readonly<{
     latest?: boolean;
@@ -35,7 +36,7 @@ export declare function snapshotActivityLines(snapshot: RenderedSnapshot, contex
 /** One command's append-only activity view, with a baseline and a final tail flush. */
 export type ActivityStream = ((snapshot: RenderedSnapshot) => readonly string[]) & Readonly<{
     /** Seed the sequence cursor without spending the command's live evidence budget. */
-    seed: (snapshot: RenderedSnapshot) => void;
+    seed: (snapshot: RenderedSnapshot) => readonly string[];
     /** Emit the deferred tail exactly once before the command's conclusion. */
     flush: () => readonly string[];
 }>;

package/build/src/cli/render/akuma-activity.js

@@ -236,48 +236,61 @@ function orderedSnapshotEntries(snapshot) {
     return entries;
 }
 /**
- * Focus one complete snapshot without making its provider-side gaps mean more
- * than they do. Thought rows disappear; known tool rows use the same opening
- * and recent budgets as live activity, while every other row keeps its place.
+ * The current open turn starts from either its initial commission or a Tell
+ * delivered when the Body launched it. A live Tell belongs to an already
+ * pursuing turn and is not its boundary.
  */
-function focusedSnapshotEntries(entries) {
-    const tools = entries.filter((entry) => entry.kind === "row" && entry.row.kind === "tool");
-    const focused = [];
-    let toolIndex = 0;
-    let omittedTools = 0;
-    const flushOmittedTools = () => {
-        if (omittedTools > 0)
-            focused.push({ kind: "gap", count: omittedTools });
-        omittedTools = 0;
-    };
-    for (const entry of entries) {
-        if (entry.kind === "row" && entry.row.kind === "thought")
-            continue;
-        if (entry.kind !== "row" || entry.row.kind !== "tool") {
-            flushOmittedTools();
-            focused.push(entry);
-            continue;
+function currentTurnBoundary(snapshot) {
+    if (snapshot.kind !== "open")
+        return undefined;
+    const rows = snapshot.entries.flatMap((entry) => (entry.kind === "row" ? [entry.row] : []));
+    const wake = rows.findLast((row) => row.kind === "tell" &&
+        row.state === "told" &&
+        row.deliveries.some((delivery) => delivery.route === "launch" && delivery.turnSequence === snapshot.turn.turnSequence));
+    if (wake !== undefined)
+        return { row: wake, turnSequence: snapshot.turn.turnSequence };
+    const call = rows.find((row) => row.kind === "call" && row.turnSequence === snapshot.turn.turnSequence);
+    return call === undefined ? undefined : { row: call, turnSequence: snapshot.turn.turnSequence };
+}
+/** Move the visible current-turn boundary ahead of activity without duplicating it. */
+function boundaryFirstSnapshotEntries(snapshot) {
+    const entries = orderedSnapshotEntries(snapshot);
+    const boundary = currentTurnBoundary(snapshot);
+    if (boundary === undefined)
+        return entries;
+    return [
+        { kind: "row", row: boundary.row },
+        ...entries.filter((entry) => entry.kind !== "row" || entry.row !== boundary.row),
+    ];
+}
+/** Open status hides internal thought narration without selecting a second activity window. */
+function visibleOpenSnapshotEntries(snapshot) {
+    return boundaryFirstSnapshotEntries(snapshot).filter((entry) => entry.kind !== "row" || entry.row.kind !== "thought");
+}
+/** Adjacent omitted spans are one continuous unknown portion of the retained timeline. */
+function coalesceAdjacentGaps(entries) {
+    return entries.reduce((coalesced, entry) => {
+        const previous = coalesced.at(-1);
+        if (entry.kind === "gap" && previous?.kind === "gap") {
+            coalesced[coalesced.length - 1] = { kind: "gap", count: previous.count + entry.count };
         }
-        const keep = toolIndex < OPENING_TOOL_BUDGET || toolIndex >= tools.length - RECENT_TOOL_BUDGET;
-        toolIndex += 1;
-        if (keep)
-            flushOmittedTools();
-        else
-            omittedTools += 1;
-        if (keep)
-            focused.push(entry);
-    }
-    flushOmittedTools();
-    return focused;
+        else {
+            coalesced.push(entry);
+        }
+        return coalesced;
+    }, []);
 }
 /**
- * Shared snapshot activity rendering. Full snapshots focus known tool evidence;
- * `latest` preserves compact callers' established newest-entry selection.
+ * Shared snapshot activity rendering. Full snapshots render the selected
+ * activity evidence; an idle snapshot is settled evidence. `latest` preserves
+ * compact callers' established newest-entry selection.
  */
 export function snapshotActivityLines(snapshot, context, selection = {}) {
     const entries = orderedSnapshotEntries(snapshot);
-    if (selection.latest !== true)
-        return groupedEntries(focusedSnapshotEntries(entries), context);
+    if (selection.latest !== true) {
+        const full = snapshot.kind === "open" ? visibleOpenSnapshotEntries(snapshot) : entries;
+        return groupedEntries(coalesceAdjacentGaps(full), context);
+    }
     const latest = entries.filter((entry) => entry.kind === "row").at(-1);
     return latest === undefined ? [] : groupedEntries([latest], context);
 }
@@ -344,15 +357,25 @@ function flushSafeActivityPrefix(state, lines, context, layout) {
         lines.push(layout.marker(first.count));
     }
 }
+function renderCurrentTurnBoundary(state, snapshot, lines, context, layout) {
+    const boundary = currentTurnBoundary(snapshot);
+    if (boundary !== undefined && !state.renderedBoundaries.has(boundary.turnSequence)) {
+        renderStreamRow(state, boundary.row, lines, context, layout);
+        state.renderedBoundaries.add(boundary.turnSequence);
+    }
+    return boundary;
+}
 function observeActivitySnapshot(state, snapshot, context, layout) {
+    const lines = [];
+    const boundary = renderCurrentTurnBoundary(state, snapshot, lines, context, layout);
     const rows = settledRows(snapshot)
+        .filter((row) => row !== boundary?.row)
         .filter((row) => state.newestSequence === undefined || row.sequence > state.newestSequence)
         // Thoughts remain retained activity, but are ineligible for default live progress.
         .filter((row) => row.kind !== "thought");
     if (rows.length === 0)
-        return [];
+        return lines;
     state.newestSequence = rows.reduce((newest, row) => Math.max(newest, row.sequence), state.newestSequence ?? rows[0].sequence);
-    const lines = [];
     for (const row of rows) {
         if (row.kind === "tool" && state.openingTools < OPENING_TOOL_BUDGET) {
             state.openingTools += 1;
@@ -395,13 +418,17 @@ export function activityStream(context, layout = plainLayout()) {
     const state = {
         newestSequence: undefined,
         previousClock: undefined,
+        renderedBoundaries: new Set(),
         openingTools: 0,
         deferred: [],
     };
     const seed = (snapshot) => {
+        const lines = [];
+        renderCurrentTurnBoundary(state, snapshot, lines, context, layout);
         const rows = settledRows(snapshot);
         if (rows.length > 0)
             state.newestSequence = rows.reduce((newest, row) => Math.max(newest, row.sequence), rows[0].sequence);
+        return lines;
     };
     const observe = (snapshot) => observeActivitySnapshot(state, snapshot, context, layout);
     const flush = () => flushActivityTail(state, context, layout);
@@ -481,7 +508,7 @@ function observeWaitRound(state, round, context, now) {
                 : plainLayout());
             state.streams.set(status.id, stream);
             // A wait starts at the current settled frontier: its backlog is neither evidence nor budget.
-            stream.seed(status.timeline);
+            lines.push(...stream.seed(status.timeline));
         }
         else {
             lines.push(...known(status.timeline));

package/build/src/git/private-state-seat.js

@@ -2,7 +2,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { join } from "node:path";
 import { acquireSqliteTransactionLock, SqliteTransactionLockError } from "../coordination/sqlite-transaction-lock.js";
 const PRIVATE_STATE_SEAT = "private-state.sqlite";
-const PRIVATE_STATE_SEAT_ACQUIRE_TIMEOUT_MS = 5_000;
+const PRIVATE_STATE_SEAT_ACQUIRE_TIMEOUT_MS = 15_000;
 const privateStateSeat = Symbol("private-state-seat");
 const confirmedPublications = new WeakSet();
 const heldPrivateStateSeats = new AsyncLocalStorage();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "4.5.21",
+  "version": "4.5.23",
   "workspaces": [
     "plugins/*"
   ],