@astrosheep/keiyaku 4.5.24 → 4.5.26

package/build/src/akuma/body.js

@@ -1,7 +1,7 @@
 import { appendFile, stat } from "node:fs/promises";
 import { basename, delimiter, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { abortableDelay } from "./abort.js";
+import { abortable, abortableDelay } from "./abort.js";
 import { BodySupervisor } from "./body-supervisor.js";
 import { driveTurn, turnRecipe } from "./turn-drive.js";
 import { HeldAkumaLeash, breakBody, decidePendingTellDisposition, drainPendingTells, endTurn, failOpenBoundTurns, finishBodyIfIdle, heartExists, isHeartAbsent, probeLeash, projectTell, readHeart, readOpenBoundTurns, readOpenPendingTellDisposition, readTell, readTurn, readNonterminalRequests, resolvePendingTellDisposition, } from "./heart/index.js";
@@ -587,50 +587,68 @@ function failedChild(exit) {
         child: { code: exit.code, signal: exit.signal, log: exit.log },
     };
 }
-async function awaitWake(paths, tellId, after, child, schedule) {
-    for (;;) {
-        const settled = await settledWake(paths, tellId, after);
-        if (settled !== null) {
-            child.release();
-            return settled;
-        }
-        const timerController = new AbortController();
-        const timer = schedule(WAKE_REREAD_MS, timerController.signal).then(() => ({ kind: "timer" }));
-        let winner;
-        try {
-            winner = await Promise.race([child.exited.then((exit) => ({ kind: "exited", exit })), timer]);
-        }
-        catch (error) {
+async function awaitWake(paths, input) {
+    const { tellId, after, child, schedule, signal } = input;
+    try {
+        for (;;) {
+            signal?.throwIfAborted();
+            const settled = await settledWake(paths, tellId, after);
+            if (settled !== null) {
+                child.release();
+                return settled;
+            }
+            const timerController = new AbortController();
+            const timer = schedule(WAKE_REREAD_MS, timerController.signal).then(() => ({ kind: "timer" }));
+            let winner;
+            try {
+                const waited = Promise.race([child.exited.then((exit) => ({ kind: "exited", exit })), timer]);
+                winner = signal === undefined ? await waited : await abortable(waited, signal);
+            }
+            catch (error) {
+                timerController.abort();
+                await timer.catch(() => undefined);
+                throw error;
+            }
+            if (winner.kind === "timer")
+                continue;
             timerController.abort();
             await timer.catch(() => undefined);
-            throw error;
-        }
-        if (winner.kind === "timer")
-            continue;
-        timerController.abort();
-        await timer.catch(() => undefined);
-        const final = await settledWake(paths, tellId, after);
-        if (final !== null) {
-            child.release();
-            return final;
+            const final = await settledWake(paths, tellId, after);
+            if (final !== null) {
+                child.release();
+                return final;
+            }
+            return winner.exit.code === LEASH_HELD_EXIT ? { kind: "held" } : failedChild(winner.exit);
         }
-        return winner.exit.code === LEASH_HELD_EXIT ? { kind: "held" } : failedChild(winner.exit);
+    }
+    catch (error) {
+        child.release();
+        throw error;
     }
 }
-async function wakePendingTells(paths, tellId, runtime) {
+async function wakePendingTells(paths, tellId, runtime, signal) {
     try {
+        signal?.throwIfAborted();
         const beforeHeart = await readHeart(paths);
         if (tellId === undefined && beforeHeart.pending.length === 0)
             return null;
         const before = beforeHeart.latestBody?.sequence ?? 0;
-        return await awaitWake(paths, tellId, before, await runtime.spawn(paths), runtime.schedule ?? abortableDelay);
+        return await awaitWake(paths, {
+            ...(tellId === undefined ? {} : { tellId }),
+            after: before,
+            child: await runtime.spawn(paths),
+            schedule: runtime.schedule ?? abortableDelay,
+            ...(signal === undefined ? {} : { signal }),
+        });
     }
     catch (error) {
+        if (signal?.aborted)
+            throw error;
         return { kind: "failed", diagnostic: diagnostic(error) };
     }
 }
-export async function wakeRecordedTell(paths, tellId, runtime = DIRECT_TELL_WAKE) {
-    const wake = (await wakePendingTells(paths, tellId, runtime));
+export async function wakeRecordedTell(paths, tellId, runtime = DIRECT_TELL_WAKE, signal) {
+    const wake = (await wakePendingTells(paths, tellId, runtime, signal));
     const tell = await readTell(paths, tellId);
     if (tell === null)
         throw new Error(`recorded Tell ${tellId} is missing from Heart`);

package/build/src/akuma/call-request.d.ts

@@ -30,7 +30,6 @@ declare const akumaCallPayloadSchema: z.ZodObject<{
     archetype: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
     body: z.ZodOptional<z.ZodString>;
     initiator: z.ZodOptional<z.ZodString>;
-    awaitAsleep: z.ZodOptional<z.ZodLiteral<true>>;
     cwd: z.ZodOptional<z.ZodString>;
     recipe: z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;

package/build/src/akuma/call-request.js

@@ -68,7 +68,6 @@ const akumaCallPayloadSchema = z
     archetype: archetypeSchema,
     body: z.string().optional(),
     initiator: z.string().min(1).optional(),
-    awaitAsleep: z.literal(true).optional(),
     cwd: absolutePathSchema.optional(),
     recipe: akumaCallRecipeSchema,
 })
@@ -105,7 +104,6 @@ async function executeAkumaCall(request, facts, capabilities) {
         worldPath: world,
         archetype: request.archetype,
         signal: facts.signal,
-        ...(request.awaitAsleep === undefined ? {} : { awaitAsleep: request.awaitAsleep }),
         launch: async (allocated) => {
             if (!facts.admissionOpen())
                 throw new Error("body closed request admission");
@@ -129,6 +127,7 @@ async function executeAkumaCall(request, facts, capabilities) {
 export function akumaCallRequestProtocol() {
     return {
         action: "akuma.call",
+        supportsCancellation: true,
         encodeRequest: callPayload,
         decodeRequest: decodeAkumaCallRequest,
         encodeResult: (result) => result,

package/build/src/akuma/fleet-execution.d.ts

@@ -1,4 +1,5 @@
 import { type AkumaStatus } from "./akuma.js";
+import type { ActivityRow } from "./projection.js";
 import { type DispatchAssociation } from "./dispatch-association.js";
 import type { AkumaAlias } from "../identity/selector.js";
 import type { WorldRoot } from "../world.js";
@@ -12,6 +13,7 @@ export type WaitIdentityFacts = Readonly<{
 /** One observed Akuma as a live wait viewer sees it: its status plus its identity facts. */
 export type WaitObservedAkuma = Readonly<{
     status: AkumaStatus;
+    rows: readonly ActivityRow[];
 }> & WaitIdentityFacts;
 /** One selected Akuma's frozen identity, resolved before the first observation round. */
 export type WaitSelectedAkuma = Readonly<{
@@ -34,7 +36,7 @@ export type WaitExecutionInput = Readonly<{
     selectionOrder?: readonly AkumaStatus["id"][];
     /** Reports the frozen selected set before the first round, so a viewer can fix its layout. */
     onSelected?: (selected: readonly WaitSelectedAkuma[]) => void;
-    /** Reports every observation round to a live viewer; absent keeps the cheap completion probe. */
+    /** Reports every observation round to a live viewer. */
     observe?: (observed: readonly WaitObservedAkuma[]) => void;
 }>;
 export declare function executeWaitAkuma(input: WaitExecutionInput): Promise<AkumaWaitResult>;

package/build/src/akuma/fleet-execution.js

@@ -1,6 +1,6 @@
 import { AkumaNotBornError, defaultWaitComplete } from "./akuma.js";
 import { createAkumaProduct } from "./akuma-product.js";
-import { readBudgetedStatus, readWaitComplete } from "./akuma-observe.js";
+import { readLiveStatus, waitForObservation } from "./akuma-observe.js";
 import { NO_DISPATCH_ASSOCIATION } from "./dispatch-association.js";
 import { EMPTY_CREATED_TASK_OBSERVATION } from "../task/created-observation.js";
 import { fleetResultSchemas, parseAkumaObservation, } from "./fleet-observation.js";
@@ -11,7 +11,6 @@ function observationDiagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
 const SHARED_ORDINARY_BUDGET = 30;
-const POLL_MS = 100;
 function akumaOnlyObservation(status) {
     return parseAkumaObservation({
         status,
@@ -22,19 +21,17 @@ function akumaOnlyObservation(status) {
 async function observeWaitRound(path, ids, signal) {
     signal?.throwIfAborted();
     if (ids.length <= 1) {
-        return {
-            statuses: await Promise.all(ids.map(async (id) => await source(path).selectHandle({ id }).status())),
-            unobserved: [],
-        };
+        const observations = await Promise.all(ids.map(async (id) => await readLiveStatus(path, id, { aperture: "monitoring" })));
+        return { observations, unobserved: [] };
     }
     let remaining = SHARED_ORDINARY_BUDGET;
-    const statuses = [];
+    const observations = [];
     const unobserved = [];
     for (const id of ids) {
         signal?.throwIfAborted();
         try {
-            const observed = await readBudgetedStatus(path, id, { aperture: "monitoring", ordinaryBudget: remaining });
-            statuses.push(observed.status);
+            const observed = await readLiveStatus(path, id, { aperture: "monitoring", ordinaryBudget: remaining });
+            observations.push(observed);
             remaining -= observed.ordinarySelected;
         }
         catch (error) {
@@ -43,50 +40,13 @@ async function observeWaitRound(path, ids, signal) {
             unobserved.push({ id, diagnostic: observationDiagnostic(error) });
         }
     }
-    return { statuses, unobserved };
-}
-async function probeWaitRound(input) {
-    let observed = 0;
-    let complete = 0;
-    for (const id of input.ids) {
-        input.signal?.throwIfAborted();
-        try {
-            if (await readWaitComplete(input.path, id))
-                complete += 1;
-            observed += 1;
-        }
-        catch (error) {
-            if (input.ids.length <= 1 || error instanceof AkumaNotBornError)
-                throw error;
-            // Plural wait retries unreadable members; final rendering owns diagnostics.
-        }
-    }
-    return observed > 0 && (input.completion === "any" ? complete > 0 : complete === input.ids.length);
+    return { observations, unobserved };
 }
 function roundComplete(round, completion) {
-    const settled = round.statuses.map(defaultWaitComplete);
+    const settled = round.observations.map((observation) => defaultWaitComplete(observation.status));
     return (settled.length > 0 &&
         (completion === "any" ? settled.some(Boolean) : round.unobserved.length === 0 && settled.every(Boolean)));
 }
-function delay(milliseconds, signal) {
-    return new Promise((resolve, reject) => {
-        let timer;
-        const done = () => {
-            signal?.removeEventListener("abort", abort);
-            resolve();
-        };
-        const abort = () => {
-            clearTimeout(timer);
-            signal?.removeEventListener("abort", abort);
-            reject(signal?.reason ?? new Error("upstream request aborted"));
-        };
-        timer = setTimeout(done, milliseconds);
-        if (signal?.aborted)
-            abort();
-        else
-            signal?.addEventListener("abort", abort, { once: true });
-    });
-}
 /** Canonical ids in the caller's selection order, appending any id the caller never named. */
 function selectionOrderedIds(ids, order) {
     const present = new Set(ids);
@@ -107,7 +67,6 @@ function selectionOrderedIds(ids, order) {
     return ordered;
 }
 export async function executeWaitAkuma(input) {
-    const deadline = input.timeoutMs === undefined ? undefined : performance.now() + input.timeoutMs;
     // Identity facts are read once per observed Akuma, not once per 100ms round.
     const facts = new Map();
     if (input.onSelected !== undefined) {
@@ -119,47 +78,47 @@ export async function executeWaitAkuma(input) {
         const ordered = input.selectionOrder === undefined ? input.ids : selectionOrderedIds(input.ids, input.selectionOrder);
         input.onSelected(ordered.map((id) => ({ id, ...facts.get(id) })));
     }
-    const observeRound = async (statuses) => {
+    const observeRound = async (round) => {
         if (input.observe === undefined)
             return;
         const observed = [];
-        for (const status of statuses) {
+        for (const observation of round.observations) {
             input.signal?.throwIfAborted();
+            const { status, rows } = observation;
             let known = facts.get(status.id);
             if (known === undefined && input.identity !== undefined) {
                 known = await input.identity(status.id);
                 facts.set(status.id, known);
             }
             if (known === undefined) {
-                observed.push({ status, contract: NO_DISPATCH_ASSOCIATION });
+                observed.push({ status, rows, contract: NO_DISPATCH_ASSOCIATION });
                 continue;
             }
-            observed.push({ status, ...known });
+            observed.push({ status, rows, ...known });
         }
         input.observe(observed);
     };
-    for (;;) {
-        const expired = deadline !== undefined && performance.now() >= deadline;
-        if (expired || input.observe !== undefined || (await probeWaitRound(input))) {
-            const round = await observeWaitRound(input.path, input.ids, input.signal);
-            input.signal?.throwIfAborted();
-            await observeRound(round.statuses);
-            // The probe is not a completion receipt. Judge the actual returned values.
-            if (roundComplete(round, input.completion) || (deadline !== undefined && performance.now() >= deadline)) {
-                return fleetResultSchemas.wait.parse({
-                    completion: input.completion,
-                    observations: round.statuses.map(akumaOnlyObservation),
-                    unobserved: round.unobserved,
-                });
-            }
-        }
-        await delay(deadline === undefined ? POLL_MS : Math.min(POLL_MS, Math.max(0, deadline - performance.now())), input.signal);
-    }
+    const waited = await waitForObservation({
+        ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+        observe: async () => await observeWaitRound(input.path, input.ids, input.signal),
+        complete: (round) => roundComplete(round, input.completion),
+        onObserve: async (round) => await observeRound(round),
+    });
+    return fleetResultSchemas.wait.parse({
+        mode: input.completion,
+        reason: waited.reason,
+        observations: waited.value.observations.map((observation) => akumaOnlyObservation(observation.status)),
+        unobserved: waited.value.unobserved,
+    });
 }
 export async function executeTellAkuma(input) {
     input.signal?.throwIfAborted();
     const handle = source(input.path).selectHandle({ id: input.id });
-    const tell = await handle.tell(input.body, input.tellId, input.recordedAt, undefined, input.initiator === undefined ? {} : { initiator: input.initiator });
+    const tell = await handle.tell(input.body, input.tellId, input.recordedAt, undefined, {
+        ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+    });
     input.signal?.throwIfAborted();
     return fleetResultSchemas.tell.parse({
         akuma: input.id,

package/build/src/akuma/fleet-observation.d.ts

@@ -245,6 +245,7 @@ declare const akumaObservationSchema: z.ZodObject<{
                 }, z.core.$strict>]>;
             }, z.core.$strict>]>>>;
             omitted: z.ZodNumber;
+            openingSequence: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>, z.ZodObject<{
             reportedChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                 sequence: z.ZodNumber;
@@ -449,10 +450,14 @@ declare const akumaUnobservedSchema: z.ZodObject<{
     diagnostic: z.ZodString;
 }, z.core.$strict>;
 declare const akumaWaitResultSchema: z.ZodObject<{
-    completion: z.ZodEnum<{
+    mode: z.ZodEnum<{
         any: "any";
         all: "all";
     }>;
+    reason: z.ZodEnum<{
+        deadline: "deadline";
+        completed: "completed";
+    }>;
     observations: z.ZodArray<z.ZodObject<{
         status: z.ZodObject<{
             id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
@@ -699,6 +704,7 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                     }, z.core.$strict>]>;
                 }, z.core.$strict>]>>>;
                 omitted: z.ZodNumber;
+                openingSequence: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strict>, z.ZodObject<{
                 reportedChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                     sequence: z.ZodNumber;
@@ -1022,10 +1028,14 @@ export declare function isKillResult(value: unknown): value is AkumaKillResult;
 export declare function isTellResult(value: unknown): value is AkumaTellResult;
 export declare const fleetResultSchemas: {
     wait: z.ZodObject<{
-        completion: z.ZodEnum<{
+        mode: z.ZodEnum<{
             any: "any";
             all: "all";
         }>;
+        reason: z.ZodEnum<{
+            deadline: "deadline";
+            completed: "completed";
+        }>;
         observations: z.ZodArray<z.ZodObject<{
             status: z.ZodObject<{
                 id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
@@ -1272,6 +1282,7 @@ export declare const fleetResultSchemas: {
                         }, z.core.$strict>]>;
                     }, z.core.$strict>]>>>;
                     omitted: z.ZodNumber;
+                    openingSequence: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strict>, z.ZodObject<{
                     reportedChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                         sequence: z.ZodNumber;

package/build/src/akuma/fleet-observation.js

@@ -50,7 +50,8 @@ const akumaUnobservedSchema = z.object({ id: akumaIdSchema, diagnostic: z.string
 const akumaKillResultItemSchema = z.object({ id: akumaIdSchema, evidence: killEvidenceSchema }).strict();
 const akumaWaitResultSchema = z
     .object({
-    completion: z.enum(["any", "all"]),
+    mode: z.enum(["any", "all"]),
+    reason: z.enum(["completed", "deadline"]),
     observations: z.array(akumaObservationSchema),
     unobserved: z.array(akumaUnobservedSchema),
 })

package/build/src/akuma/fleet-request.js

@@ -10,8 +10,8 @@ const fleetTargetsSchema = z
     .array(akumaIdSchema)
     .min(1)
     .superRefine((ids, context) => {
-    if (ids.some((id, index) => index > 0 && ids[index - 1] >= id))
-        context.addIssue({ code: "custom", message: "expected a strictly ordered target set" });
+    if (new Set(ids).size !== ids.length)
+        context.addIssue({ code: "custom", message: "expected a deduplicated target set" });
 });
 const waitRequestSchema = z
     .object({
@@ -92,6 +92,7 @@ function decodedFleetResult(action, value) {
 export function fleetRequestProtocol(action) {
     return {
         action,
+        supportsCancellation: true,
         encodeRequest: (request) => {
             const { action: _action, ...payload } = request;
             return payload;

package/build/src/akuma/heart/timeline.d.ts

@@ -13,6 +13,6 @@ export type StatusFactInput = Readonly<{
     aperture: "monitoring" | "receipt";
     admittedTellId?: string;
 }>;
-/** Select the frontier and Tell pins, not an arbitrary tail of raw events. */
+/** Select the frontier and its delivered Tells, plus aperture-required Tell pins. */
 export declare function statusFacts(database: DatabaseSync, input: StatusFactInput): readonly TimelineFact[];
 export declare function activityFactSlice(database: DatabaseSync): ActivityFactSlice;

package/build/src/akuma/heart/timeline.js

@@ -88,7 +88,7 @@ function decodeTimelineRows(database, rows) {
         return fact;
     });
 }
-/** Select the frontier and Tell pins, not an arbitrary tail of raw events. */
+/** Select the frontier and its delivered Tells, plus aperture-required Tell pins. */
 export function statusFacts(database, input) {
     const frontier = database.prepare("SELECT sequence FROM turns ORDER BY sequence DESC LIMIT 1").get();
     const rows = database
@@ -97,13 +97,13 @@ export function statusFacts(database, input) {
       UNION SELECT end_sequence FROM turns WHERE sequence = ? AND end_sequence IS NOT NULL
       UNION SELECT sequence FROM calls WHERE turn_sequence = ?
       UNION SELECT sequence FROM activity WHERE turn_sequence = ?
-      UNION SELECT MAX(end_sequence) FROM turns
+      UNION SELECT tells.sequence FROM tells
+      JOIN tell_deliveries ON tell_deliveries.tell_id = tells.id
+      WHERE tell_deliveries.turn_sequence = ?
       UNION SELECT sequence FROM tells WHERE id = ?
       UNION SELECT sequence FROM tells WHERE ? AND ${tellStateSql} = 'pending'
-      UNION SELECT MAX(sequence) FROM tells WHERE ? AND ${tellStateSql} = 'told'
-      UNION SELECT MAX(sequence) FROM tells
     ) SELECT timeline.sequence, timeline.kind FROM timeline JOIN selected USING(sequence) ORDER BY sequence`)
-        .all(frontier?.sequence ?? null, frontier?.sequence ?? null, frontier?.sequence ?? null, frontier?.sequence ?? null, input.admittedTellId ?? null, input.aperture === "monitoring" || input.admittedTellId === undefined ? 1 : 0, input.aperture === "monitoring" ? 1 : 0);
+        .all(frontier?.sequence ?? null, frontier?.sequence ?? null, frontier?.sequence ?? null, frontier?.sequence ?? null, frontier?.sequence ?? null, input.admittedTellId ?? null, input.aperture === "monitoring" || input.admittedTellId === undefined ? 1 : 0);
     return decodeTimelineRows(database, rows);
 }
 export function activityFactSlice(database) {

package/build/src/akuma/projection-read.js

@@ -101,18 +101,41 @@ function frontierReportedChanges(ledger) {
 function isPendingTell(row) {
     return row.kind === "tell" && row.state === "pending";
 }
-function isToldTell(row) {
-    return row.kind === "tell" && row.state === "told";
-}
 function isActiveTool(row) {
     return row.kind === "tool" && row.state === "active";
 }
+function isProtectedCurrentTurnActivity(row) {
+    return (row.kind === "said" ||
+        (row.kind === "tool" && row.call.kind === "fileChange" && row.state !== "active" && row.state !== "unsettled"));
+}
+function isSettledTellDeliveredTo(row, turnSequence) {
+    return (row.kind === "tell" &&
+        row.state === "told" &&
+        row.deliveries.some((delivery) => delivery.turnSequence === turnSequence));
+}
+function currentTurnWindow(ledger) {
+    const turn = ledger.openTurn;
+    if (turn === undefined)
+        return [];
+    const turnRows = new Set(turn.rows);
+    return ledger.rows.filter((row) => turnRows.has(row) || isSettledTellDeliveredTo(row, turn.turn.turnSequence));
+}
+function openingInput(ledger) {
+    const turn = ledger.openTurn;
+    if (turn === undefined)
+        return undefined;
+    const call = turn.rows.find((row) => row.kind === "call");
+    if (call !== undefined)
+        return call;
+    return ledger.rows.find((row) => row.kind === "tell" &&
+        row.state === "told" &&
+        row.deliveries.some((delivery) => delivery.route === "launch" && delivery.turnSequence === turn.turn.turnSequence));
+}
 export function selectSnapshot(ledger, input) {
     const budget = input.budget ?? { tail: DEFAULT_TAIL, voice: DEFAULT_VOICE };
     if (ledger.turns.length === 0 && !ledger.rows.some((row) => row.kind === "tell"))
         return { snapshot: { kind: "unborn", entries: [], omitted: 0, ...EMPTY_REPORTED }, ordinaryCount: 0 };
     const pending = ledger.rows.filter(isPendingTell);
-    const latestTold = input.aperture === "monitoring" ? ledger.rows.findLast(isToldTell) : undefined;
     const admittedTell = input.aperture === "receipt" && input.admittedTellId !== undefined
         ? ledger.rows.find((row) => row.kind === "tell" && row.tellId === input.admittedTellId)
         : undefined;
@@ -120,11 +143,17 @@ export function selectSnapshot(ledger, input) {
         ? admittedTell === undefined
             ? []
             : [admittedTell]
-        : [...pending, ...(latestTold === undefined ? [] : [latestTold])];
+        : pending;
     const reported = frontierReportedChanges(ledger);
     if (ledger.openTurn !== undefined) {
-        const window = ledger.openTurn.rows;
-        const pinSet = new Set([...window.filter(isActiveTool), ...pins]);
+        const window = currentTurnWindow(ledger);
+        const opening = openingInput(ledger);
+        const pinSet = new Set([
+            ...window.filter(isActiveTool),
+            ...window.filter(isProtectedCurrentTurnActivity),
+            ...pins,
+            ...(opening === undefined ? [] : [opening]),
+        ]);
         const ordinary = window.filter((row) => !pinSet.has(row));
         const tailCount = Math.max(0, budget.tail);
         const tail = tailCount === 0 ? [] : ordinary.slice(-tailCount);
@@ -140,6 +169,7 @@ export function selectSnapshot(ledger, input) {
                 turn: ledger.openTurn.turn,
                 entries: assembleEntries(ledger, window, selected),
                 omitted,
+                ...(opening === undefined ? {} : { openingSequence: opening.sequence }),
                 ...reported,
             },
             ordinaryCount: tail.length + voice.length,

package/build/src/akuma/projection.d.ts

@@ -733,6 +733,7 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [z.ZodObject<{
         }, z.core.$strict>]>;
     }, z.core.$strict>]>>>;
     omitted: z.ZodNumber;
+    openingSequence: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>, z.ZodObject<{
     reportedChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         sequence: z.ZodNumber;

package/build/src/akuma/projection.js

@@ -3,6 +3,7 @@ import { projectTell } from "./heart/facts.js";
 import { z } from "zod";
 const nonblankTextSchema = z.string().refine((value) => value.trim() !== "");
 const countSchema = z.number().int().nonnegative();
+const sequenceSchema = z.number().int().positive();
 const timestampSchema = z.string().refine((value) => Number.isFinite(Date.parse(value)), "expected timestamp");
 const diffstatSchema = z.object({ added: countSchema, removed: countSchema }).strict();
 const fileChangeSchema = z
@@ -162,6 +163,28 @@ const reportedChangeFields = {
     reportedChanges: z.array(reportedFileChangeSchema).readonly(),
     reportedChangesOmitted: countSchema,
 };
+const openActivitySnapshotSchema = z
+    .object({
+    kind: z.literal("open"),
+    turn: turnRowSchema,
+    entries: z.array(snapshotEntrySchema(openSnapshotRowSchema)).readonly(),
+    omitted: countSchema,
+    openingSequence: sequenceSchema.optional(),
+    ...reportedChangeFields,
+})
+    .strict()
+    .superRefine((snapshot, context) => {
+    if (snapshot.openingSequence === undefined)
+        return;
+    const matches = snapshot.entries.filter((entry) => entry.kind === "row" && entry.row.sequence === snapshot.openingSequence);
+    if (matches.length !== 1) {
+        context.addIssue({
+            code: "custom",
+            path: ["openingSequence"],
+            message: "openingSequence must name exactly one snapshot entry",
+        });
+    }
+});
 export const activitySnapshotSchema = z.union([
     z
         .object({
@@ -171,15 +194,7 @@ export const activitySnapshotSchema = z.union([
         ...reportedChangeFields,
     })
         .strict(),
-    z
-        .object({
-        kind: z.literal("open"),
-        turn: turnRowSchema,
-        entries: z.array(snapshotEntrySchema(openSnapshotRowSchema)).readonly(),
-        omitted: countSchema,
-        ...reportedChangeFields,
-    })
-        .strict(),
+    openActivitySnapshotSchema,
     z
         .object({
         kind: z.literal("idle"),

package/build/src/akuma/providers/pi/index.d.ts

@@ -1,8 +1,9 @@
-import type { createAgentSession, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
+import type { createAgentSession, createBashToolDefinition, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
 import type { ProviderExecution } from "../../provider-recipe.js";
 import { type ProviderAdapter } from "../../provider.js";
 export type PiSdk = Readonly<{
     createAgentSession(options?: CreateAgentSessionOptions): ReturnType<typeof createAgentSession>;
+    createBashToolDefinition: typeof createBashToolDefinition;
     DefaultResourceLoader: typeof DefaultResourceLoader;
     getAgentDir: typeof getAgentDir;
     ModelRuntime: typeof ModelRuntime;

package/build/src/akuma/providers/pi/index.js

@@ -54,7 +54,7 @@ async function piCreateOptions(sdk, input) {
     const customTools = input.requests === undefined || input.options.readonly === true
         ? undefined
         : [
-            (await import("@earendil-works/pi-coding-agent")).createBashToolDefinition(input.cwd, {
+            sdk.createBashToolDefinition(input.cwd, {
                 spawnHook: (context) => ({
                     ...context,
                     env: akumaExecutionEnvironment(context.env, {}, input.requests.dir, ["PI_SESSION_ID", "PI_SESSION_FILE"]),
@@ -228,6 +228,7 @@ async function loadPiSdk() {
     const sdk = await import("@earendil-works/pi-coding-agent");
     return {
         createAgentSession: sdk.createAgentSession,
+        createBashToolDefinition: sdk.createBashToolDefinition,
         DefaultResourceLoader: sdk.DefaultResourceLoader,
         getAgentDir: sdk.getAgentDir,
         ModelRuntime: sdk.ModelRuntime,