@fungi.computer/shiitake 0.5.0 → 0.6.0

package/dist/internal/runtime-reconciliation.js

@@ -5,21 +5,19 @@ import * as Schema from "effect/Schema";
 import { agentTurnRecovery } from "./accepted-run-executor.js";
 import { ShiitakeError } from "../errors.js";
 import { ExtensionId } from "../extension-contract.js";
-import { coreConsumer } from "./extension-runtime.js";
+import { coreConsumer, reportConsumer, } from "./extension-runtime.js";
 import { publishOwnerObservation } from "./observation-kernel.js";
-import { advanceCursor, readCursor, readExtensionAdmissionOrigin, readSettledRunFacts, readSettlementContent, readSettlementDiagnostic, readSettlementMeta, recordWorkSettlement, sessionLineageRefused, settleControls, } from "./woodstock/index.js";
+import { advanceCursor, readCursor, readExtensionAdmissionOrigin, readSettledRunFacts, readSettlementContent, readSettlementDiagnostic, readSessionDelegator, readSettlementMeta, readWaitingOn, readWaitingOnSender, recordWorkSettlement, sessionLineageRefused, settleControls, } from "./woodstock/index.js";
 const pageSize = 64;
 function runtimeFailure(message) {
     return new ShiitakeError("runtime", "rejected", message);
 }
-function fanOutSettlement(store, mailRoom, job) {
-    if (mailRoom === undefined)
-        return Effect.void;
+/** BirdDog's settlement facts for one settled job, without its correspondents. */
+function settlementFacts(store, job, 
+/** The open items this settlement names as waiting on its recipient. */
+waitingOnYou) {
     return Effect.gen(function* () {
-        const payload = yield* Effect.try({
-            try: () => decodeAgentJob(job),
-            catch: () => runtimeFailure("Agent work payload is invalid"),
-        });
+        const payload = yield* decodeJob(job);
         const content = job.outcome === "cancelled"
             ? ""
             : yield* readSettlementContent(store, payload.work);
@@ -27,14 +25,103 @@ function fanOutSettlement(store, mailRoom, job) {
         const diagnostic = job.outcome === "completed" || job.outcome === "cancelled"
             ? undefined
             : yield* readSettlementDiagnostic(store, payload.work);
-        const settled = diagnostic === undefined
-            ? { job, content }
-            : { job, content, diagnostic };
-        yield* mailRoom
-            .fanOut(meta === undefined ? settled : { ...settled, meta })
-            .pipe(Effect.mapError(() => runtimeFailure("Agent reply fan-out is unavailable")));
+        let settled = { job, content };
+        if (diagnostic !== undefined)
+            settled = { ...settled, diagnostic };
+        // A cancelled run names nothing; what it left open is the canceller's to see.
+        const waiting = job.outcome === "cancelled" ? [] : yield* waitingOnYou;
+        if (waiting.length > 0)
+            settled = { ...settled, waitingOnYou: waiting };
+        return meta === undefined ? settled : { ...settled, meta };
     });
 }
+function decodeJob(job) {
+    return Effect.try({
+        try: () => decodeAgentJob(job),
+        catch: () => runtimeFailure("Agent work payload is invalid"),
+    });
+}
+function fanOut(mailRoom, settled) {
+    return mailRoom
+        .fanOut(settled)
+        .pipe(Effect.mapError(() => runtimeFailure("Agent reply fan-out is unavailable")));
+}
+/** Reply to the delegating mail that admitted this work, if it asked for one. */
+function replyToMail(store, mailRoom, job) {
+    if (mailRoom === undefined)
+        return Effect.void;
+    return Effect.gen(function* () {
+        const payload = yield* decodeJob(job);
+        if ((payload.mail?.replyTo.length ?? 0) === 0)
+            return;
+        // The reply goes to the mail's sender: name what waits on that sender.
+        const waiting = Effect.try({
+            try: () => readWaitingOnSender(store, payload.work.sessionId, payload.work.commandFactId),
+            catch: () => runtimeFailure("Session attention is unavailable"),
+        });
+        yield* fanOut(mailRoom, yield* settlementFacts(store, job, waiting));
+    });
+}
+/**
+ * Report work no delegating mail answered to the Session's delegator of
+ * record. It runs after the extensions have seen the settlement, so a goal
+ * or loop that admitted the next turn keeps the Session busy and the stretch
+ * of turns reports once, when the Session finally rests. Another Agent's
+ * original mail is that Agent's correspondence and never reported here.
+ */
+function reportToDelegator(store, watchdog, mailRoom, job) {
+    if (mailRoom === undefined)
+        return Effect.void;
+    return Effect.gen(function* () {
+        const payload = yield* decodeJob(job);
+        const mail = payload.mail;
+        if (mail !== undefined && mail.replyTo.length > 0)
+            return;
+        const head = yield* watchdog
+            .readQueueHead(job.queue)
+            .pipe(Effect.mapError(() => runtimeFailure("Session queue head is unavailable")));
+        if (head.state !== "idle")
+            return;
+        const delegator = yield* Effect.try({
+            try: () => readSessionDelegator(store, payload.work.sessionId),
+            catch: () => runtimeFailure("Session delegator is unavailable"),
+        });
+        if (delegator === undefined)
+            return;
+        const from = mail?.reply === undefined ? mail?.from : undefined;
+        const anotherAgentsMail = from !== undefined &&
+            !(from.kind === "agent" &&
+                delegator.replyTo.some(({ agentId }) => agentId === from.agentId));
+        if (anotherAgentsMail)
+            return;
+        // The report goes to the delegator: name what waits on it.
+        const waiting = Effect.try({
+            try: () => readWaitingOn(store, payload.work.sessionId, delegator.replyTo),
+            catch: () => runtimeFailure("Session attention is unavailable"),
+        });
+        const settled = yield* settlementFacts(store, job, waiting);
+        yield* fanOut(mailRoom, { ...settled, delegator });
+    });
+}
+/**
+ * The `core-report` settled consumer: after the extensions' turn, report each
+ * Session's last settled job in the page, one record at a time.
+ */
+function reportSettled(store, watchdog, mailRoom, records) {
+    return Effect.forEach(records, (record, index) => Effect.gen(function* () {
+        const later = records
+            .slice(index + 1)
+            .some(({ job }) => job.queue === record.job.queue);
+        if (!later && !(yield* settledInRefusedSession(store, record.job)))
+            yield* reportToDelegator(store, watchdog, mailRoom, record.job);
+        yield* Effect.try({
+            try: () => {
+                advanceCursor(store, reportConsumer, record.sequence);
+            },
+            catch: () => runtimeFailure("Settled cursor is unavailable"),
+        });
+    }), { discard: true });
+}
 function repairWorkSettlement(store, job) {
     const outcome = job.outcome;
     if (outcome !== "interrupted" &&
@@ -148,7 +235,7 @@ function settleCore(store, watchdog, mailRoom, records) {
         if (!(yield* settledInRefusedSession(store, record.job))) {
             yield* repairWorkSettlement(store, record.job);
             yield* settleTargetedControls(store, watchdog, record.job);
-            yield* fanOutSettlement(store, mailRoom, record.job);
+            yield* replyToMail(store, mailRoom, record.job);
         }
         yield* Effect.try({
             try: () => {
@@ -172,26 +259,34 @@ export function reconcileRuntime(input) {
             try: () => readCursor(input.store, coreConsumer) ?? 0,
             catch: () => runtimeFailure("Settled cursor is unavailable"),
         });
+        const reportCursor = yield* Effect.try({
+            try: () => readCursor(input.store, reportConsumer) ?? coreCursor,
+            catch: () => runtimeFailure("Settled cursor is unavailable"),
+        });
         const consumers = input.extensions.settledConsumers();
-        const after = Math.min(coreCursor, ...consumers.map(({ cursor }) => cursor));
+        const after = Math.min(coreCursor, reportCursor, ...consumers.map(({ cursor }) => cursor));
         const page = yield* input.watchdog.readSettled(pageSize, after);
         const core = yield* Effect.exit(settleCore(input.store, input.watchdog, input.mailRoom, page.filter(({ sequence }) => sequence > coreCursor)));
+        const processed = yield* Effect.try({
+            try: () => readCursor(input.store, coreConsumer) ?? 0,
+            catch: () => runtimeFailure("Settled cursor is unavailable"),
+        });
         const runs = yield* Effect.try({
-            try: () => {
-                const processed = readCursor(input.store, coreConsumer) ?? 0;
-                return page
-                    .filter(({ sequence }) => sequence <= processed)
-                    .map((record) => settledRun(input.store, record));
-            },
+            try: () => page
+                .filter(({ sequence }) => sequence <= processed)
+                .map((record) => settledRun(input.store, record)),
             catch: () => runtimeFailure("Settled run facts are unavailable"),
         });
-        yield* input.extensions.deliverSettled(runs, readCursor(input.store, coreConsumer) ?? 0);
+        yield* input.extensions.deliverSettled(runs, processed);
+        const reports = yield* Effect.exit(reportSettled(input.store, input.watchdog, input.mailRoom, page.filter(({ sequence }) => sequence > reportCursor && sequence <= processed)));
         const moreTimers = yield* input.extensions.fireDueTimers(Date.now());
         if (page.length === pageSize || moreTimers)
             yield* input.requestWake;
         yield* drainMail(input.mailRoom);
         if (Exit.isFailure(core))
             return yield* Effect.failCause(core.cause);
+        if (Exit.isFailure(reports))
+            return yield* Effect.failCause(reports.cause);
     }).pipe(Effect.mapError((failure) => failure instanceof ShiitakeError
         ? failure
         : runtimeFailure("Runtime reconciliation failed")));

package/dist/internal/woodstock/agent-reply.d.ts

@@ -9,6 +9,11 @@ export declare const VerifiedAgentReplySchema: Schema.Union<readonly [Schema.Str
     readonly commandId: Schema.String;
     readonly outcome: Schema.Literals<readonly ["completed", "failed", "interrupted", "cancelled", "outcome_unknown"]>;
     readonly diagnostic: Schema.optionalKey<Schema.String>;
+    readonly waitingOnYou: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly itemId: Schema.String;
+        readonly kind: Schema.String;
+        readonly summary: Schema.String;
+    }>>>;
     readonly agentId: Schema.String;
     readonly sessionId: Schema.String;
 }>, Schema.Struct<{

package/dist/internal/woodstock/agent-reply.js

@@ -42,6 +42,9 @@ function opening(reply) {
     attributes.push(["outcome", reply.outcome]);
     if (reply.outcome !== "undeliverable" && reply.diagnostic !== undefined)
         attributes.push(["diagnostic", reply.diagnostic]);
+    if (reply.outcome !== "undeliverable" && reply.waitingOnYou !== undefined)
+        // A host fact, outside the child's text: the items the child left waiting on the recipient.
+        attributes.push(["waiting_on_you", JSON.stringify(reply.waitingOnYou)]);
     if (reply.outcome === "undeliverable")
         attributes.push(["reason", reply.reason]);
     const rendered = attributes

package/dist/internal/woodstock/client-projection.js

@@ -1,9 +1,11 @@
 import { messageAuthor } from "@fungi.computer/agar/agents";
 import { readSessionAttention } from "./session-attention.js";
+import { readWaitingOnSender } from "./work-senders.js";
+import { readSessionDelegator } from "./session-delegator.js";
 import { ShiitakeError } from "../../errors.js";
 import { decodeWoodstockCursor, encodeWoodstockCursor } from "./cursor.js";
 import { operatorClientMessage, promptCommand } from "./session-entry.js";
-import { lineageEntrySequence, lineageHasSequence, lineageRowLimit, readLineageWindow, readLineageWorkFacts, readSessionEntriesForWork, readSessionLineage, readPendingSessionCommands, readSessionCommandAdmission, readNewestPendingSessionCommand, } from "./session-store.js";
+import { lineageEntrySequence, lineageHasSequence, lineageRowLimit, readLineageWindow, readLineageWorkFacts, hasSessionWorkTerminal, readSessionEntriesForWork, readSessionLineage, readPendingSessionCommands, readSessionCommandAdmission, readNewestPendingSessionCommand, } from "./session-store.js";
 const maximumPagePayloadBytes = 2_097_152;
 const replayPageLimit = 200;
 const maximumRowsPerPage = lineageRowLimit;
@@ -503,6 +505,10 @@ export function projectCommandSettlement(owner, sessionId, commandId) {
     const admission = readSessionCommandAdmission(owner, sessionId, commandId);
     if (admission === undefined)
         throw unavailable("Accepted Session command is unavailable");
+    // A live work has no settlement to project. The owner's terminal index
+    // answers this without decoding the work again on every polling tick.
+    if (!hasSessionWorkTerminal(owner, sessionId, admission.entry.workId))
+        return undefined;
     const rows = readSessionEntriesForWork(owner, sessionId, admission.entry.workId);
     const work = workFacts(owner, sessionId, rows);
     const terminal = rows
@@ -521,6 +527,7 @@ export function projectCommandSettlement(owner, sessionId, commandId) {
     const sender = messageAuthor(admission.entry.meta);
     return {
         acceptedSender: sender?.kind === "agent" ? sender.id : null,
+        delegator: readSessionDelegator(owner, sessionId)?.replyTo[0]?.agentId ?? null,
         terminal: meta === undefined ? terminal : { ...terminal, meta },
         content: terminal.outcome === "cancelled"
             ? ""
@@ -534,5 +541,6 @@ export function projectCommandSettlement(owner, sessionId, commandId) {
             usage,
         })),
         toolCalls: new Set(rows.flatMap(({ entry }) => entry.kind === "tool_intent" ? [entry.call.id] : [])).size,
+        waitingOnYou: readWaitingOnSender(owner, sessionId, admission.entry.workId),
     };
 }

package/dist/internal/woodstock/index.d.ts

@@ -15,6 +15,8 @@ export * from "./extension-store.js";
 export { readLatestPendingPrompt } from "./client-projection.js";
 export { createFleetDirectoryStore, createFleetDelegationStore, } from "./fleet-store.js";
 export * from "./session-attention.js";
+export * from "./work-senders.js";
+export * from "./session-delegator.js";
 export { deliverSessionGrants, prepareSessionGrants, readSessionGrants, type GrantsDelivery, type GrantsDeliveryResult, } from "./session-grants.js";
 export * from "./progress.js";
 export * from "./compaction-activity.js";
@@ -138,6 +140,8 @@ export declare function readSessionFactPage(owner: SqliteOwner, after?: string):
 export declare function readColdSessionPage(owner: SqliteOwner, request: ColdSessionPageRequest): Effect.Effect<ColdSessionPage, ShiitakeError>;
 /** Read one bounded inbox page in tier, then newest-activity order. */
 export declare function readSessionInbox(owner: SqliteOwner, after: string | undefined): Effect.Effect<import("../../client.js").SessionSummaryPage, ShiitakeError>;
+/** Read a Session's open attention items from the store alone. */
+export declare function readStoredSessionAttention(owner: SqliteOwner, sessionId: string): Effect.Effect<readonly import("../../client.js").SessionAttention[], ShiitakeError>;
 /** Read one strict-after page from Woodstock's selected lineage. */
 export declare function readSessionReplayPage(owner: SqliteOwner, sessionId: string, after: string | undefined, delivery: "replay" | "live", activity: ObservedActivity, projectExtensions?: () => SessionExtensionSlots, includeSandboxFailures?: boolean): Effect.Effect<ClientReplayPage, ShiitakeError>;
 /** Persist an operator-only sandbox diagnostic beside its accepted Session work. */

package/dist/internal/woodstock/index.js

@@ -9,10 +9,13 @@ import { openProgress, openToolProgress } from "./progress.js";
 import { encodeStoredSessionEntry, } from "./session-entry.js";
 import { appendSessionEntry, appendCompactionTransitionOwned, appendCompactionNoticeOwned, placeCompactionTransitionOwned, acceptSessionAbort, acceptSessionCancellation, completeSessionLeaf, prepareSessionRun, prepareSessionStore, readSessionEntriesForWork, readSessionCommandAdmission, settleSessionControls, takePendingSessionControls, readSessionEntryById, selectSessionBranch, forkSessionAt, readStoredSessionSummary as readSessionSummaryOwned, readStoredSessionFactPage, createStoredSession, createStoredSessionWithinTransaction, deleteStoredSession, appendOperatorEntry, } from "./session-store.js";
 import { readSessionInboxPage, recordSessionInboxDeletion, } from "./session-inbox.js";
+import { readSessionAttention } from "./session-attention.js";
 export * from "./extension-store.js";
 export { readLatestPendingPrompt } from "./client-projection.js";
 export { createFleetDirectoryStore, createFleetDelegationStore, } from "./fleet-store.js";
 export * from "./session-attention.js";
+export * from "./work-senders.js";
+export * from "./session-delegator.js";
 export { deliverSessionGrants, prepareSessionGrants, readSessionGrants, } from "./session-grants.js";
 export * from "./progress.js";
 export * from "./compaction-activity.js";
@@ -228,6 +231,10 @@ export function readColdSessionPage(owner, request) {
 export function readSessionInbox(owner, after) {
     return storeEffect(() => readSessionInboxPage(owner, after));
 }
+/** Read a Session's open attention items from the store alone. */
+export function readStoredSessionAttention(owner, sessionId) {
+    return storeEffect(() => readSessionAttention(owner, sessionId));
+}
 /** Read one strict-after page from Woodstock's selected lineage. */
 export function readSessionReplayPage(owner, sessionId, after, delivery, activity, projectExtensions = () => ({}), includeSandboxFailures = false) {
     return storeEffect(() => readClientReplayPage(owner, decodeClientSessionId(sessionId), after, delivery, activity, projectExtensions, includeSandboxFailures));

package/dist/internal/woodstock/session-delegator.d.ts

@@ -0,0 +1,12 @@
+import type { BirdDogDelegator, BirdDogMail } from "@fungi.computer/bird-dog";
+import type { SqliteOwner } from "../contracts.js";
+/** Woodstock keeps each Session's delegator of record beside the Session. */
+export declare function prepareSessionDelegators(owner: SqliteOwner): void;
+/**
+ * Record who sent a Session its work first, in the admitting transaction.
+ * Only an original mail that asks for replies names a delegator; the first one
+ * stays, so the relationship never moves once it exists.
+ */
+export declare function recordSessionDelegator(owner: SqliteOwner, sessionId: string, mail: BirdDogMail | undefined): void;
+/** The Session's delegator of record, if any Agent has sent it work. */
+export declare function readSessionDelegator(owner: SqliteOwner, sessionId: string): BirdDogDelegator | undefined;

package/dist/internal/woodstock/session-delegator.js

@@ -0,0 +1,44 @@
+import { BirdDogAgentReferenceSchema } from "@fungi.computer/bird-dog/effect";
+import * as Schema from "effect/Schema";
+const decodeRow = Schema.decodeUnknownSync(Schema.Struct({
+    mail_key: Schema.String,
+    agent_id: Schema.String,
+    reply_to_json: Schema.fromJsonString(Schema.Array(BirdDogAgentReferenceSchema)),
+}));
+const encodeReplyTo = Schema.encodeSync(Schema.fromJsonString(Schema.Array(BirdDogAgentReferenceSchema)));
+/** Woodstock keeps each Session's delegator of record beside the Session. */
+export function prepareSessionDelegators(owner) {
+    owner.sql.exec(`CREATE TABLE IF NOT EXISTS session_delegators (
+    session_id TEXT PRIMARY KEY,
+    mail_key TEXT NOT NULL,
+    agent_id TEXT NOT NULL,
+    reply_to_json TEXT NOT NULL
+  )`);
+}
+/**
+ * Record who sent a Session its work first, in the admitting transaction.
+ * Only an original mail that asks for replies names a delegator; the first one
+ * stays, so the relationship never moves once it exists.
+ */
+export function recordSessionDelegator(owner, sessionId, mail) {
+    if (mail === undefined ||
+        mail.reply !== undefined ||
+        mail.from.kind !== "agent" ||
+        mail.replyTo.length === 0)
+        return;
+    owner.sql.exec("INSERT OR IGNORE INTO session_delegators (session_id, mail_key, agent_id, reply_to_json) VALUES (?, ?, ?, ?)", sessionId, mail.key, mail.to.agentId, encodeReplyTo(mail.replyTo));
+}
+/** The Session's delegator of record, if any Agent has sent it work. */
+export function readSessionDelegator(owner, sessionId) {
+    const [row] = owner.sql
+        .exec("SELECT mail_key, agent_id, reply_to_json FROM session_delegators WHERE session_id = ?", sessionId)
+        .toArray();
+    if (row === undefined)
+        return undefined;
+    const decoded = decodeRow(row);
+    return {
+        key: decoded.mail_key,
+        agentId: decoded.agent_id,
+        replyTo: decoded.reply_to_json,
+    };
+}

package/dist/internal/woodstock/session-entry.d.ts

@@ -74,6 +74,11 @@ declare const StoredSessionEntrySchema: Schema.Union<readonly [Schema.Struct<{
         readonly commandId: Schema.String;
         readonly outcome: Schema.Literals<readonly ["completed", "failed", "interrupted", "cancelled", "outcome_unknown"]>;
         readonly diagnostic: Schema.optionalKey<Schema.String>;
+        readonly waitingOnYou: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly itemId: Schema.String;
+            readonly kind: Schema.String;
+            readonly summary: Schema.String;
+        }>>>;
         readonly agentId: Schema.String;
         readonly sessionId: Schema.String;
     }>, Schema.Struct<{
@@ -357,15 +362,20 @@ export declare function decodeStoredSessionEntry(value: string): Result.Result<{
     readonly delivery?: "followUp" | "steer";
     readonly meta?: import("../../extensions.js").Json;
     readonly reply?: {
+        readonly agentId: string;
         readonly sessionId: string;
         readonly commandId: string;
         readonly outcome: "completed" | "failed" | "cancelled" | "interrupted" | "outcome_unknown";
-        readonly agentId: string;
         readonly diagnostic?: string;
+        readonly waitingOnYou?: readonly {
+            readonly itemId: string;
+            readonly kind: string;
+            readonly summary: string;
+        }[];
     } | {
+        readonly agentId: string;
         readonly reason: "recipient_offline" | "recipient_left";
         readonly outcome: "undeliverable";
-        readonly agentId: string;
         readonly sessionId?: string;
     };
     readonly targetWorkId?: string;

package/dist/internal/woodstock/session-store.d.ts

@@ -237,6 +237,8 @@ export declare function settleSessionControls(owner: SqliteOwner, input: Readonl
 export declare function readSessionCommandAdmission(owner: SqliteOwner, sessionId: string, id: string): StoredCommandAdmission | undefined;
 /** Read one stable private command admission by accepted request identity. */
 export declare function readSessionCommandAdmissionByRequest(owner: SqliteOwner, sessionId: string, requestId: string): StoredCommandAdmission | undefined;
+/** Probe the indexed terminal facts without materializing a live work's body. */
+export declare function hasSessionWorkTerminal(owner: SqliteOwner, sessionId: string, workId: string): boolean;
 /** Read entries correlated to one accepted work identity in Session order. */
 export declare function readSessionEntriesForWork(owner: SqliteOwner, sessionId: string, workId: string): readonly StoredSessionRow[];
 /** Read the latest retained live-retry event for one accepted work item. */

package/dist/internal/woodstock/session-store.js

@@ -7,6 +7,8 @@ import { compactionSummaryMessage } from "../compaction/utils.js";
 import { SessionTitleSchema, sessionTitleLimit } from "../client-boundary.js";
 import { commandTimestamp, decodeStoredSessionEntry, encodeStoredSessionEntry, isCompactCommand, commandContextMessage, operatorContextMessage, promptCommand, } from "./session-entry.js";
 import { prepareSessionAttention } from "./session-attention.js";
+import { prepareWorkSenders } from "./work-senders.js";
+import { prepareSessionDelegators } from "./session-delegator.js";
 import { copySessionGrants, prepareSessionGrants } from "./session-grants.js";
 import { prepareSessionInbox, touchSessionInbox } from "./session-inbox.js";
 import { sessionIds } from "./identities.js";
@@ -680,6 +682,18 @@ function readSessionCommandAdmissionByWorkId(owner, sessionId, workId) {
 export function readSessionCommandAdmissionByRequest(owner, sessionId, requestId) {
     return readCommandAdmission(owner, sessionId, { requestId });
 }
+/** Probe the indexed terminal facts without materializing a live work's body. */
+export function hasSessionWorkTerminal(owner, sessionId, workId) {
+    // Keep the readability check even when the work has no terminal rows.
+    readSessionRow(owner, sessionId);
+    return (owner.sql
+        .exec(`SELECT 1 AS present FROM session_entries
+         INDEXED BY idx_session_entries_work_terminal
+         WHERE session_id = ? AND work_id = ?
+           AND type IN ('run_terminal', 'work_terminal')
+         LIMIT 1`, sessionId, workId)
+        .toArray().length > 0);
+}
 /** Read entries correlated to one accepted work identity in Session order. */
 export function readSessionEntriesForWork(owner, sessionId, workId) {
     // Refuse the Session before selecting entries: a damaged work may have no
@@ -832,6 +846,7 @@ export function deleteStoredSession(owner, input) {
             "DELETE FROM session_command_admissions WHERE session_id = ?",
             // The inbox row references the Session; it goes in the same transaction.
             "DELETE FROM session_attention WHERE session_id = ?",
+            "DELETE FROM session_work_senders WHERE session_id = ?",
             "DELETE FROM session_tool_grants WHERE session_id = ?",
             "DELETE FROM session_inbox WHERE session_id = ?",
             "DELETE FROM session_creation_receipts WHERE session_id = ?",
@@ -1128,6 +1143,8 @@ export function prepareSessionStore(owner) {
         createSessionEntryTable(owner);
         prepareSessionDocuments(owner);
         prepareSessionAttention(owner);
+        prepareWorkSenders(owner);
+        prepareSessionDelegators(owner);
         prepareSessionGrants(owner);
         prepareSessionInbox(owner);
         owner.sql.exec(`
@@ -1143,6 +1160,9 @@ export function prepareSessionStore(owner) {
        ON session_entries(session_id, request_id)
        WHERE request_id IS NOT NULL`);
         owner.sql.exec("CREATE INDEX IF NOT EXISTS idx_session_entries_work ON session_entries(work_id, sequence)");
+        owner.sql.exec(`CREATE INDEX IF NOT EXISTS idx_session_entries_work_terminal
+       ON session_entries(session_id, work_id)
+       WHERE type IN ('run_terminal', 'work_terminal')`);
         // Context and preference reads look up these rare older facts directly
         // rather than walking the history behind them.
         owner.sql.exec(`CREATE INDEX IF NOT EXISTS idx_session_entries_model_preference

package/dist/internal/woodstock/work-senders.d.ts

@@ -0,0 +1,32 @@
+import { type AttentionRecipient } from "../../session-attention.js";
+import type { SqliteOwner } from "../contracts.js";
+/** One open item of a Session that waits on the Agent that sent its work. */
+export type WaitingOnYou = Readonly<{
+    itemId: string;
+    kind: string;
+    summary: string;
+}>;
+/**
+ * Woodstock records which Agent Session sent each accepted run, beside the
+ * run's admission. Attention that an extension raises during a run waits on
+ * this sender first; a run no Agent sent has no row.
+ */
+export declare function prepareWorkSenders(owner: SqliteOwner): void;
+/** Record the sender of one accepted run; a replay writes the same row. */
+export declare function recordWorkSender(owner: SqliteOwner, sessionId: string, workId: string, sender: AttentionRecipient): void;
+/** The Agent Session that sent this run, or undefined when none did. */
+export declare function readWorkSender(owner: SqliteOwner, sessionId: string, workId: string): AttentionRecipient | undefined;
+/**
+ * The Session's open attention that waits on the sender of this run, newest
+ * first as stored, bounded. Escalated items wait on someone else and are
+ * absent; a run no Agent sent names none.
+ */
+export declare function readWaitingOnSender(owner: SqliteOwner, sessionId: string, workId: string): readonly WaitingOnYou[];
+/**
+ * The Session's open attention that waits on any of these Agent Sessions,
+ * newest first as stored, bounded: what a reply or report to them names.
+ */
+export declare function readWaitingOn(owner: SqliteOwner, sessionId: string, recipients: readonly Readonly<{
+    agentId: string;
+    sessionId: string;
+}>[]): readonly WaitingOnYou[];

package/dist/internal/woodstock/work-senders.js

@@ -0,0 +1,70 @@
+import * as Schema from "effect/Schema";
+import { AttentionRecipientSchema, } from "../../session-attention.js";
+import { readSessionAttention } from "./session-attention.js";
+/** The most open items one settlement names as waiting on its sender. */
+const maximumWaitingOnYou = 8;
+const decodeRow = Schema.decodeUnknownSync(Schema.Struct({
+    agent_id: Schema.String,
+    sender_session_id: Schema.String,
+    name: Schema.String,
+}));
+const decodeRecipient = Schema.decodeUnknownSync(AttentionRecipientSchema);
+/**
+ * Woodstock records which Agent Session sent each accepted run, beside the
+ * run's admission. Attention that an extension raises during a run waits on
+ * this sender first; a run no Agent sent has no row.
+ */
+export function prepareWorkSenders(owner) {
+    owner.sql.exec(`CREATE TABLE IF NOT EXISTS session_work_senders (
+    session_id TEXT NOT NULL,
+    work_id TEXT NOT NULL,
+    agent_id TEXT NOT NULL,
+    sender_session_id TEXT NOT NULL,
+    name TEXT NOT NULL,
+    PRIMARY KEY (session_id, work_id)
+  )`);
+}
+/** Record the sender of one accepted run; a replay writes the same row. */
+export function recordWorkSender(owner, sessionId, workId, sender) {
+    owner.sql.exec(`INSERT OR IGNORE INTO session_work_senders
+       (session_id, work_id, agent_id, sender_session_id, name)
+     VALUES (?, ?, ?, ?, ?)`, sessionId, workId, sender.agentId, sender.sessionId, sender.name);
+}
+/** The Agent Session that sent this run, or undefined when none did. */
+export function readWorkSender(owner, sessionId, workId) {
+    const raw = owner.sql
+        .exec("SELECT agent_id, sender_session_id, name FROM session_work_senders WHERE session_id = ? AND work_id = ?", sessionId, workId)
+        .toArray()[0];
+    if (raw === undefined)
+        return undefined;
+    const row = decodeRow(raw);
+    return decodeRecipient({
+        agentId: row.agent_id,
+        sessionId: row.sender_session_id,
+        name: row.name,
+    });
+}
+/**
+ * The Session's open attention that waits on the sender of this run, newest
+ * first as stored, bounded. Escalated items wait on someone else and are
+ * absent; a run no Agent sent names none.
+ */
+export function readWaitingOnSender(owner, sessionId, workId) {
+    const sender = readWorkSender(owner, sessionId, workId);
+    return sender === undefined ? [] : readWaitingOn(owner, sessionId, [sender]);
+}
+/**
+ * The Session's open attention that waits on any of these Agent Sessions,
+ * newest first as stored, bounded: what a reply or report to them names.
+ */
+export function readWaitingOn(owner, sessionId, recipients) {
+    return readSessionAttention(owner, sessionId)
+        .filter((item) => recipients.some((recipient) => item.waitingOn?.agentId === recipient.agentId &&
+        item.waitingOn.sessionId === recipient.sessionId))
+        .slice(0, maximumWaitingOnYou)
+        .map((item) => ({
+        itemId: item.id,
+        kind: item.kind,
+        summary: item.summary,
+    }));
+}

package/dist/remote-client.js

@@ -72,7 +72,12 @@ function remoteEvents(url, clientClosed, sources, eventSource) {
                 closed: false,
             };
             const emit = (kind, event) => {
-                Queue.offerUnsafe(queue, { kind, event });
+                if (!Queue.offerUnsafe(queue, { kind, event })) {
+                    // A dropped frame breaks this watch's ordering. Fail instead
+                    // of delivering an incomplete history to the client.
+                    Queue.failCauseUnsafe(queue, Cause.fail(unavailable("Session stream client fell behind")));
+                    Effect.runSync(closeRemoteSource(active, sources));
+                }
             };
             active.source.addEventListener("snapshot", (event) => {
                 emit("snapshot", event);
@@ -91,7 +96,7 @@ function remoteEvents(url, clientClosed, sources, eventSource) {
             return active;
         },
         catch: () => unavailable("Session stream could not open"),
-    }), (active) => closeRemoteSource(active, sources))).pipe(Stream.mapEffect(decodeRemoteEvent), Stream.interruptWhen(clientClosed.await));
+    }), (active) => closeRemoteSource(active, sources)), { bufferSize: 256, strategy: "dropping" }).pipe(Stream.mapEffect(decodeRemoteEvent), Stream.interruptWhen(clientClosed.await));
 }
 function sessionUrl(baseUrl, sessionId) {
     return `${baseUrl}/sessions/${encodeURIComponent(sessionId)}`;

package/dist/server-visitor-stream.d.ts

@@ -0,0 +1,13 @@
+import type { SessionSnapshot, SessionWatch } from "./client.js";
+export type VisitorStreamError = "channel_visitor_stream_expiry_failed" | "channel_visitor_stream_close_failed" | "channel_visitor_stream_heartbeat_failed" | "channel_visitor_stream_failed";
+export declare function visitorStream(options: Readonly<{
+    watch: SessionWatch;
+    visitorId: string;
+    filter: (snapshot: SessionSnapshot) => SessionSnapshot;
+    expiresAt: number;
+    now: () => number;
+    release: () => void;
+    canRead: () => Promise<boolean>;
+    read: () => Promise<SessionSnapshot>;
+    onError: (event: VisitorStreamError, cause: unknown) => void;
+}>): ReadableStream<Uint8Array>;