@fungi.computer/shiitake 0.5.0 → 0.7.0

package/dist/internal/coordinator.js

@@ -1,16 +1,17 @@
 import { nanoid } from "@fungi.computer/cairn";
 import { parseModelPreference } from "./model-preference.js";
 import { acceptedNotice } from "@fungi.computer/bird-dog/effect";
+import { FungiMessageMetaSchema } from "@fungi.computer/agar/agents";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Stream from "effect/Stream";
 import { ShiitakeError } from "../errors.js";
 import { decodeClientReadOptions, decodeClientSettlementRequest, requireDecoded, decodeClientSessionCommand, decodeClientSessionId, decodeClientSubscribeOptions, } from "./client-boundary.js";
-import { mergeObservationSignals, openObservationKernel, publishOwnerObservation, } from "./observation-kernel.js";
+import { mergeObservationSignals, openObservationKernel, publishAgentExecutionChange, publishOwnerObservation, } from "./observation-kernel.js";
 import { checkHostMeta } from "./host-meta.js";
-import { readSessionActivity } from "./session-status.js";
-import { readSessionContext } from "./session-context.js";
-import { abortSession, cancelSession, branchSession, recordOperatorLine, forkSession, readSession, readCommandSettlement, readSessionModelPreference, readSessionReplayPage, readSessionInbox, readLatestPendingPrompt, createSession, deleteSession, deliverSessionGrants, readSessionGrants, setSessionModelPreference, setSessionTitle, readAdmissionIdentity, assertAdmissionIdentity, } from "./woodstock/index.js";
+import { readSessionActivity, } from "./session-status.js";
+import { prepareSessionContext } from "./session-context.js";
+import { progressPosition, readProcessProgressDelta, abortSession, cancelSession, branchSession, recordOperatorLine, forkSession, readSession, readCommandSettlement, readSessionModelPreference, readSessionReplayPage, readSessionInbox, readLatestPendingPrompt, createSession, deleteSession, deliverSessionGrants, readSessionGrants, setSessionModelPreference, setSessionTitle, readAdmissionIdentity, assertAdmissionIdentity, } from "./woodstock/index.js";
 /** Generic Agent-scope extension controls over the runtime's one call door. */
 function agentExtensions(runtime) {
     return Object.freeze({
@@ -19,12 +20,15 @@ function agentExtensions(runtime) {
         call: (extensionId, command, input) => runtime.assertOpen.pipe(Effect.andThen(runtime.extensions.call({ scope: "agent" }, extensionId, command, input))),
     });
 }
-function currentSessionActivity(options, runtime, sessionId) {
+function currentSessionWork(runtime, sessionId) {
     return runtime
         .readQueueHead(sessionId)
         .pipe(Effect.flatMap((head) => (head.state === "queued"
         ? runtime.runningWork(head.jobId)
-        : Effect.succeed(null)).pipe(Effect.map((runningWork) => readSessionActivity(options.store, sessionId, head, runningWork)))));
+        : Effect.succeed(null)).pipe(Effect.map((runningWork) => ({ head, runningWork })))));
+}
+function currentSessionActivity(options, runtime, sessionId) {
+    return currentSessionWork(runtime, sessionId).pipe(Effect.map(({ head, runningWork }) => readSessionActivity(options.store, sessionId, head, runningWork)));
 }
 /** Carry the Session's context use on a baseline, when it has one. */
 function withContext(snapshot, context) {
@@ -34,7 +38,10 @@ function withContext(snapshot, context) {
 }
 /** Read the baseline and its context use for one Session. */
 function readSessionWithContext(options, runtime, sessionId, input) {
-    return currentSessionActivity(options, runtime, sessionId).pipe(Effect.flatMap((activity) => readSession(options.store, sessionId, activity, input, () => runtime.extensions.project(sessionId))), Effect.flatMap((snapshot) => readSessionContext(options, sessionId, snapshot.cursor, input?.before === undefined).pipe(Effect.map((context) => withContext(snapshot, context)))));
+    return currentSessionWork(runtime, sessionId).pipe(Effect.flatMap(({ head, runningWork }) => readSession(options.store, sessionId, () => readSessionActivity(options.store, sessionId, head, runningWork), input, () => runtime.extensions.project(sessionId), (snapshot) => ({
+        snapshot,
+        context: prepareSessionContext(options, sessionId, snapshot.cursor, input?.before === undefined),
+    }))), Effect.flatMap(({ snapshot, context }) => context.pipe(Effect.map((value) => withContext(snapshot, value)))));
 }
 function sessionOwnerOperation(runtime, sessionId, operation) {
     return runtime.assertOpen.pipe(Effect.andThen(Effect.try({
@@ -91,7 +98,46 @@ function continueFromReset(frame) {
         }),
     ];
 }
-function subscriptionFrames(options, runtime, registration, sessionId, after, delivery, includeSandboxFailures = false) {
+function subscriptionFrames(options, runtime, registration, sessionId, after, delivery, includeSandboxFailures = false, baselineProgress = null) {
+    let position = progressPosition(baselineProgress);
+    let toolOutput = [];
+    const reset = () => resetFrame(options, runtime, sessionId, includeSandboxFailures).pipe(Effect.map((frame) => {
+        position = progressPosition(frame.baseline.progress);
+        toolOutput = frame.baseline.toolOutput;
+        return continueFromReset(frame);
+    }));
+    const liveFrames = (activity) => {
+        const queue = activity.facts.queue;
+        const delta = queue.state !== "running"
+            ? null
+            : readProcessProgressDelta(options.store, sessionId, queue.commandId, position);
+        if (delta === undefined)
+            return undefined;
+        const frames = [];
+        if (delta !== null) {
+            frames.push({
+                kind: "progress",
+                progress: delta,
+                activity: activity.facts,
+            });
+            position = {
+                messageId: delta.messageId,
+                revision: delta.revision,
+                text: delta.text.offset + delta.text.append.length,
+                thinking: delta.thinking.offset + delta.thinking.append.length,
+            };
+        }
+        if (toolOutput.length !== activity.toolOutput.length ||
+            toolOutput.some((slot, index) => slot !== activity.toolOutput[index])) {
+            toolOutput = activity.toolOutput;
+            frames.push({
+                kind: "tool_output",
+                toolOutput,
+                activity: activity.facts,
+            });
+        }
+        return frames;
+    };
     const initial = {
         after,
         delivery,
@@ -105,64 +151,73 @@ function subscriptionFrames(options, runtime, registration, sessionId, after, de
         if (signal === "closed")
             return Effect.succeed([[], Option.none()]);
         if (signal === "reset")
-            return resetFrame(options, runtime, sessionId, includeSandboxFailures).pipe(Effect.map(continueFromReset));
+            return reset();
         return runtime.assertOpen.pipe(Effect.andThen(currentSessionActivity(options, runtime, sessionId)), Effect.flatMap((activity) => {
             registration.setQueued(activity.facts.queue.state === "queued");
-            if (signal === "activity" && state.delivery === "live")
-                return Effect.succeed([
-                    [{ kind: "activity", activity: activity.facts }],
-                    Option.some({ ...state, awaitSignal: true }),
-                ]);
-            if (signal === "progress" && state.delivery === "live") {
+            if ((signal === "progress" || signal === "activity") &&
+                state.delivery === "live") {
+                const frames = liveFrames(activity);
+                if (frames === undefined)
+                    return reset();
                 return Effect.succeed([
                     [
-                        ...(activity.progress === null
-                            ? []
-                            : [
+                        ...(signal === "activity"
+                            ? [
                                 {
-                                    kind: "progress",
-                                    progress: activity.progress,
+                                    kind: "activity",
                                     activity: activity.facts,
                                 },
-                            ]),
-                        {
-                            kind: "tool_output",
-                            toolOutput: activity.toolOutput,
-                            activity: activity.facts,
-                        },
+                            ]
+                            : []),
+                        ...frames,
                     ],
                     Option.some({ ...state, awaitSignal: true }),
                 ]);
             }
-            return readSessionReplayPage(options.store, sessionId, state.after, state.delivery, activity, () => runtime.extensions.project(sessionId), includeSandboxFailures).pipe(Effect.flatMap((page) => {
+            return readSessionReplayPage(options.store, sessionId, state.after, state.delivery, activity, () => runtime.extensions.project(sessionId), includeSandboxFailures, (page) => {
+                const latestCursor = page.kind === "page"
+                    ? page.frames
+                        .flatMap((frame) => frame.kind === "progress" ||
+                        frame.kind === "activity" ||
+                        frame.kind === "tool_output"
+                        ? []
+                        : [frame.cursor])
+                        .at(-1)
+                    : undefined;
+                // Prepare a figure only for the final moving update,
+                // while its cursor and stored context share the read.
+                const context = page.kind === "page" &&
+                    !page.hasMore &&
+                    page.frames.some((frame) => frame.kind === "update" &&
+                        frame.cursor !== state.after)
+                    ? prepareSessionContext(options, sessionId, latestCursor ?? null)
+                    : Effect.succeed(undefined);
+                return { page, latestCursor, context };
+            }).pipe(Effect.flatMap(({ page, latestCursor, context, }) => {
                 if (page.kind === "reset")
-                    return resetFrame(options, runtime, sessionId, includeSandboxFailures).pipe(Effect.map(continueFromReset));
-                const latestCursor = page.frames
-                    .flatMap((frame) => frame.kind === "progress" ||
-                    frame.kind === "activity" ||
-                    frame.kind === "tool_output"
+                    return reset();
+                if (!page.hasMore)
+                    toolOutput = activity.toolOutput;
+                const progressFrames = page.hasMore
                     ? []
-                    : [frame.cursor])
-                    .at(-1);
+                    : liveFrames(activity);
+                if (progressFrames === undefined)
+                    return reset();
                 const next = {
                     after: latestCursor ?? state.after,
                     delivery: page.hasMore ? state.delivery : "live",
                     awaitSignal: !page.hasMore,
                 };
-                // Only a final update that moves the cursor gets a
-                // figure. A wake that moved nothing never re-reads the
-                // whole kept window.
-                const movedHistory = page.frames.some((frame) => frame.kind === "update" &&
-                    frame.cursor !== state.after);
-                return (movedHistory && !page.hasMore
-                    ? readSessionContext(options, sessionId, latestCursor ?? null)
-                    : Effect.succeed(undefined)).pipe(Effect.map((context) => [
-                    context === undefined
-                        ? page.frames
-                        : page.frames.map((frame) => frame.kind === "update" &&
-                            frame.cursor === latestCursor
-                            ? Object.freeze({ ...frame, context })
-                            : frame),
+                return context.pipe(Effect.map((context) => [
+                    [
+                        ...(context === undefined
+                            ? page.frames
+                            : page.frames.map((frame) => frame.kind === "update" &&
+                                frame.cursor === latestCursor
+                                ? Object.freeze({ ...frame, context })
+                                : frame)),
+                        ...progressFrames,
+                    ],
                     Option.some(next),
                 ]));
             }));
@@ -190,7 +245,7 @@ function watchSession(options, runtime, observation, sessionId, input) {
             registration.setQueued(snapshot.activity.queue.state === "queued");
             return Object.freeze({
                 snapshot,
-                changes: subscriptionFrames(options, runtime, registration, decoded.sessionId, snapshot.cursor ?? undefined, "live", decoded.options.includeSandboxFailures === true).pipe(Stream.ensuring(Effect.sync(registration.close))),
+                changes: subscriptionFrames(options, runtime, registration, decoded.sessionId, snapshot.cursor ?? undefined, "live", decoded.options.includeSandboxFailures === true, snapshot.progress).pipe(Stream.ensuring(Effect.sync(registration.close))),
                 close: Effect.sync(registration.close),
             });
         }))).pipe(Effect.onError(() => Effect.sync(registration.close)));
@@ -288,7 +343,9 @@ function executeSessionCommand(options, runtime, sessionId, meta, input) {
                     .commit(sessionOwnerOperation(runtime, decodedSessionId, (decoded) => {
                     setSessionTitle(options.store, decoded, command.title);
                 }))
-                    .pipe(Effect.as(undefined));
+                    .pipe(Effect.tap(() => Effect.sync(() => {
+                    publishAgentExecutionChange(options.store);
+                })), Effect.as(undefined));
         }
     }));
 }
@@ -348,7 +405,7 @@ export function openCoordinator(options, runtime) {
                 })), Effect.asVoid))),
             }),
             extension: (extensionId) => Object.freeze({
-                call: (command, input) => runtime.assertOpen.pipe(Effect.andThen(runtime.extensions.call({ scope: "session", sessionId }, extensionId, command, input))),
+                call: (command, input, caller) => runtime.assertOpen.pipe(Effect.andThen(runtime.extensions.call({ scope: "session", sessionId }, extensionId, command, input, caller))),
             }),
             read: (input) => runtime.assertOpen.pipe(Effect.andThen(readSessionWithContext(options, runtime, sessionId, input))),
             readSettlement: (commandId, timeoutMs = 0) => Effect.scoped(Effect.gen(function* () {
@@ -410,6 +467,11 @@ export function openCoordinator(options, runtime) {
         }),
     });
 }
+/** Whether the sender asked this mail to steer the recipient's running turn. */
+function steersRunningTurn(mail) {
+    const meta = FungiMessageMetaSchema.safeParse(mail.meta);
+    return meta.success && meta.data.delegation?.steer === true;
+}
 /**
  * Accept one addressed mail envelope; the door decodes it as a prompt. `reply`
  * is the host's authentication of a delegated Agent's reply; only then does
@@ -449,6 +511,7 @@ export function acceptAddressedMail(runtime, mail, meta, reply, stageMail, sessi
             const result = admit(meta === undefined ? request : { ...request, meta });
             if (result.status !== "accepted")
                 throw new Error("Sessionless addressed mail was not admitted");
+            runtime.recordCreatedSessionDelegatorWithinTransaction(sessionId, addressed);
             return {
                 status: "accepted",
                 commandId: result.commandId,
@@ -458,7 +521,7 @@ export function acceptAddressedMail(runtime, mail, meta, reply, stageMail, sessi
     }
     return admitUserWork(runtime, mail.to.sessionId, {
         requestId: mail.key,
-        delivery: reply === undefined ? "followUp" : "steer",
+        delivery: reply !== undefined || steersRunningTurn(mail) ? "steer" : "followUp",
         type: "prompt",
         text: mail.content,
     }, meta, mail, reply);

package/dist/internal/effect-client.js

@@ -72,7 +72,7 @@ function sessionFacade(address, session) {
         extension: (extensionId) => {
             const extension = session.extension(extensionId);
             return Object.freeze({
-                call: (command, input) => runShiitakePromise(extension.call(command, input)),
+                call: (command, input, caller) => runShiitakePromise(extension.call(command, input, caller)),
             });
         },
         read: (input) => runShiitakePromise(session.read(input)),

package/dist/internal/effect-contracts.d.ts

@@ -1,6 +1,6 @@
 import type { HostMetaOptions } from "./host-meta.js";
 import type { ExtensionRosterV0 } from "../extensions.js";
-import type { Api, AssistantMessage, Model, MuleStreamFunction, RetryPolicy } from "@fungi.computer/mule/effect";
+import type { Api, AssistantMessage, Model, MuleStreamFunction, ProviderRejection, RetryPolicy } from "@fungi.computer/mule/effect";
 import type { CapabilitySource, ExecutionOptions, ModuleRegistration } from "@fungi.computer/mycelium";
 import type { CommandSettlement, GrantsDelivery, GrantsDeliveryResult, ToolAccess } from "./contracts.js";
 import type { Sandbox } from "@fungi.computer/mycelium/effect";
@@ -26,6 +26,8 @@ export type ModelAcquisitionEffect = Readonly<{
     retryable: (message: AssistantMessage) => boolean;
     /** Owner-authored reason for this door's failure message, never SDK prose. */
     failureReason?: (message: AssistantMessage) => string | undefined;
+    /** Bounded provider facts for this door's exact failure, never SDK prose. */
+    rejection?: (message: AssistantMessage) => ProviderRejection | undefined;
     /** Provider prose for this door's exact failed turn; never a diagnostic. */
     providerError?: (message: AssistantMessage) => string | undefined;
     /** Effect finalizer for acquired model resources. */
@@ -99,6 +101,11 @@ export type ShiitakeEffectOptions = Readonly<{
     store: SqliteOwner;
     /** Host storage-pressure check; absent never refuses for storage pressure. */
     storagePressure?: StoragePressureCheck;
+    /** Host-owned synchronous new-work admission at the common door. */
+    admission?: Readonly<{
+        /** Check the host's current flag synchronously inside admission's transaction. */
+        assertOpen: () => void;
+    }>;
     /** Compaction budgets; absent uses Pi's defaults for every model. */
     compaction?: CompactionOptions;
     /** One host lane in Shiitake's existing Watchdog, opened before recovery. */
@@ -201,7 +208,7 @@ export type ShiitakeEffectSession = Readonly<{
 /** Effect-native Session-scope extension commands. */
 export type ShiitakeEffectSessionExtension = Readonly<{
     /** Run one command with its encoded input; succeeds with the encoded output. */
-    call: (command: string, input: Json) => Effect.Effect<Json, ShiitakeError>;
+    call: (command: string, input: Json, caller?: import("../extensions.js").ExtensionCommandCallerV0) => Effect.Effect<Json, ShiitakeError>;
 }>;
 /** Effect-native Agent-scope extension controls. */
 export type ShiitakeEffectAgentExtensions = Readonly<{

package/dist/internal/extension-command-registry.d.ts

@@ -1,11 +1,12 @@
 import * as Effect from "effect/Effect";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
-import type { AdmissionError, CommandHandlersV0, CommandsV0, ExtensionCommandError, ExtensionRead, ExtensionStateError, ExtensionTx, Json } from "../extensions.js";
+import type { AdmissionError, CommandHandlersV0, CommandsV0, ExtensionCommandError, ExtensionCommandCallerV0, ExtensionRead, ExtensionStateError, ExtensionTx, Json } from "../extensions.js";
 /** A parsed invocation retains its typed handler until the transaction runs. */
 export type RegisteredExtensionCommandV0 = (frame: Readonly<{
     sessionId: string | null;
     input: Json;
+    caller?: ExtensionCommandCallerV0;
 }>) => Result.Result<() => Effect.Effect<Json, ExtensionCommandError | ExtensionStateError | AdmissionError, ExtensionTx | ExtensionRead>, Schema.SchemaError>;
 /** Capture each declared command's schemas and matching handler at activation. */
 export declare function registerExtensionCommands<C extends CommandsV0>(specs: C, handlers: CommandHandlersV0<C>): ReadonlyMap<string, RegisteredExtensionCommandV0>;

package/dist/internal/extension-command-registry.js

@@ -13,7 +13,9 @@ function bindCommand(spec, handler) {
     const decodeInput = Schema.decodeUnknownResult(spec.input, {
         onExcessProperty: "error",
     });
-    return (frame) => Result.flatMap(decodeSession(frame.sessionId), (sessionId) => Result.map(decodeInput(frame.input), (input) => () => invokeTransactionHook(() => handler({ sessionId, input })).pipe(Effect.flatMap((output) => Schema.encodeEffect(spec.output)(output).pipe(Effect.flatMap(Schema.decodeUnknownEffect(JsonValueSchema)), Effect.orDie)))));
+    return (frame) => Result.flatMap(decodeSession(frame.sessionId), (sessionId) => Result.map(decodeInput(frame.input), (input) => () => invokeTransactionHook(() => handler(frame.caller === undefined
+        ? { sessionId, input }
+        : { sessionId, input, caller: frame.caller })).pipe(Effect.flatMap((output) => Schema.encodeEffect(spec.output)(output).pipe(Effect.flatMap(Schema.decodeUnknownEffect(JsonValueSchema)), Effect.orDie)))));
 }
 /** Capture each declared command's schemas and matching handler at activation. */
 export function registerExtensionCommands(specs, handlers) {

package/dist/internal/extension-runtime.d.ts

@@ -9,6 +9,8 @@ import type { SqliteOwner } from "./contracts.js";
 import type { AdmittedExtensionV0 } from "./extension-roster.js";
 /** The settled consumer name core itself uses for mail and control repair. */
 export declare const coreConsumer = "core";
+/** Core reports to delegators after the extensions have seen a settlement. */
+export declare const reportConsumer = "core-report";
 /** Core's generic view of rostered v1 extensions. */
 export type ExtensionRuntime = Readonly<{
     /** Prepare additions without replacing any live member; apply only between turns. */
@@ -53,7 +55,7 @@ export type ExtensionRuntime = Readonly<{
         sessionId: string;
     } | {
         scope: "agent";
-    }>, extensionId: string, command: string, input: Json) => Effect.Effect<Json, ShiitakeError>;
+    }>, extensionId: string, command: string, input: Json, caller?: import("../extensions.js").ExtensionCommandCallerV0) => Effect.Effect<Json, ShiitakeError>;
     list: () => readonly ExtensionStatusV0[];
     resume: (id: string) => Effect.Effect<ExtensionStatusV0, ShiitakeError>;
     close: Effect.Effect<void, ShiitakeError>;

package/dist/internal/extension-runtime.js

@@ -12,11 +12,13 @@ import { ShiitakeError } from "../errors.js";
 import { AdmissionError, ExtensionCommandError, ExtensionRead, ExtensionStateError, ExtensionStop, ExtensionTx, } from "../extensions.js";
 import { decodeClientSessionId } from "./client-boundary.js";
 import { AsyncExtensionTransactionError, invokeExtensionHook, invokeSyncHandler, } from "./extension-hook.js";
-import { setSessionAttention, clearSessionAttention, projectSessionAttention, readAttentionSessionPage, replaceAttentionGrants, hasStoredSession, readSessionLineage, hasPendingSessionSteer, hasSuccessfulToolResult, advanceCursor, declareSessionDocument, readSessionDocument, writeSessionDocument, deleteAllRecords, deleteRecord, deleteTimer, deleteExtensionTimers, readAllRecords, readCursor, readDueTimers, readRecord, readRecordPage, readStateLedger, readStatus, readTimer, readTimerWake, writeRecord, writeStateLedger, writeStatus, writeTimer, } from "./woodstock/index.js";
+import { hasSessionAttention, setSessionAttention, clearSessionAttention, projectSessionAttention, readAttentionSessionPage, replaceAttentionGrants, hasStoredSession, readSessionLineage, hasPendingSessionSteer, readWorkSender, hasSuccessfulToolResult, advanceCursor, declareSessionDocument, readSessionDocument, writeSessionDocument, deleteAllRecords, deleteRecord, deleteTimer, deleteExtensionTimers, readAllRecords, readCursor, readDueTimers, readRecord, readRecordPage, readStateLedger, readStatus, readTimer, readTimerWake, writeRecord, writeStateLedger, writeStatus, writeTimer, } from "./woodstock/index.js";
 import { JsonValueSchema } from "./json-value.js";
-import { publishOwnerObservation } from "./observation-kernel.js";
+import { hasOwnerObservers, publishOwnerObservation, } from "./observation-kernel.js";
 /** The settled consumer name core itself uses for mail and control repair. */
 export const coreConsumer = "core";
+/** Core reports to delegators after the extensions have seen a settlement. */
+export const reportConsumer = "core-report";
 const maximumKeyLength = 256;
 const maximumRecordBytes = 1024 * 1024;
 const maximumReasonLength = 512;
@@ -288,7 +290,7 @@ export function openExtensionRuntime(input) {
             set: (sessionId, item) => {
                 const decoded = Schema.decodeUnknownResult(AttentionItemSchema, {
                     onExcessProperty: "error",
-                })(item);
+                })(item.waitingOn === undefined ? item : { ...item, inbox: false });
                 return decoded._tag === "Failure"
                     ? Effect.fail(stateError("bound", "Attention item is invalid"))
                     : mutate(sessionId, () => {
@@ -297,6 +299,7 @@ export function openExtensionRuntime(input) {
                         setSessionAttention(owner, sessionId, id, decoded.success);
                     });
             },
+            awaitsPerson: (sessionId) => requireRead(id).pipe(Effect.tap(() => grantGuard(member, "attention")), Effect.andThen(storeStep(() => hasSessionAttention(owner, sessionId)))),
             clear: (sessionId, itemId) => boundedKey(itemId, "An attention id").pipe(Effect.andThen(mutate(sessionId, () => {
                 clearSessionAttention(owner, sessionId, id, itemId);
             }))),
@@ -323,6 +326,7 @@ export function openExtensionRuntime(input) {
                             extensionId: id,
                             correlation: request.correlation ?? null,
                         },
+                        continuesWorkId: request.continuesWorkId,
                     });
                     return result.status === "accepted"
                         ? {
@@ -336,9 +340,11 @@ export function openExtensionRuntime(input) {
                     reason: error instanceof ShiitakeError
                         ? error.cause === "conflict"
                             ? "conflict"
-                            : error.cause === "closed"
-                                ? "closed"
-                                : "invalid"
+                            : error.cause === "archived"
+                                ? "archived"
+                                : error.cause === "closed"
+                                    ? "closed"
+                                    : "invalid"
                         : "invalid",
                     message: error instanceof ShiitakeError
                         ? error.message
@@ -567,6 +573,7 @@ export function openExtensionRuntime(input) {
                 send: sendFor(member),
                 timers: timersFor(member),
                 attention: attentionFor(member),
+                isObserved: (sessionId) => member.status === "running" && hasOwnerObservers(owner, sessionId),
                 sessionPosition: (sessionId) => requireRead(member.admitted.id).pipe(Effect.andThen(grantGuard(member, "state")), Effect.andThen(storeStep(() => {
                     const id = decodeClientSessionId(sessionId);
                     if (!hasStoredSession(owner, id))
@@ -575,6 +582,7 @@ export function openExtensionRuntime(input) {
                         ?.newestSequence ?? 0);
                 }))),
                 hasPendingSteer: (run) => requireRead(member.admitted.id).pipe(Effect.andThen(grantGuard(member, "run_tools")), Effect.andThen(storeStep(() => hasPendingSessionSteer(owner, decodeClientSessionId(run.sessionId), run.workId)))),
+                workSender: (run) => requireRead(member.admitted.id).pipe(Effect.andThen(grantGuard(member, "run_tools")), Effect.andThen(storeStep(() => readWorkSender(owner, decodeClientSessionId(run.sessionId), run.workId) ?? null))),
                 hasSuccessfulToolResult: (run, toolCallId) => requireRead(member.admitted.id).pipe(Effect.andThen(grantGuard(member, "run_tools")), Effect.andThen(storeStep(() => hasSuccessfulToolResult(owner, decodeClientSessionId(run.sessionId), run.workId, toolCallId)))),
                 observe: (sessionId) => requireFrame(member.admitted.id).pipe(Effect.map((frame) => {
                     frame.observed.add(sessionId);
@@ -1020,7 +1028,7 @@ export function openExtensionRuntime(input) {
                 }
                 return Object.freeze(slots);
             },
-            call: (target, extensionId, command, raw) => Effect.gen(function* () {
+            call: (target, extensionId, command, raw, caller) => Effect.gen(function* () {
                 const member = members.get(extensionId);
                 if (member?.admitted.grants.has("commands") !== true)
                     return yield* Effect.fail(new ShiitakeError("extensions", "unavailable", "Extension is unavailable"));
@@ -1049,7 +1057,9 @@ export function openExtensionRuntime(input) {
                     yield* recordStop(member, `command ${command} has no handler`, undefined, "own-transaction");
                     return yield* Effect.fail(new ShiitakeError("extensions", "unavailable", "Extension is stopped"));
                 }
-                const prepared = handler({ sessionId, input: raw });
+                const prepared = caller === undefined
+                    ? handler({ sessionId, input: raw })
+                    : handler({ sessionId, input: raw, caller });
                 if (prepared._tag === "Failure")
                     return yield* Effect.fail(new ShiitakeError("contract", "invalid", "Extension command input is invalid"));
                 const body = prepared.success();

package/dist/internal/model-acquisition.js

@@ -23,6 +23,8 @@ function asEffectAcquisition(acquisition) {
         shared = { ...shared, failureReason: acquisition.failureReason };
     if (acquisition.providerError !== undefined)
         shared = { ...shared, providerError: acquisition.providerError };
+    if (acquisition.rejection !== undefined)
+        shared = { ...shared, rejection: acquisition.rejection };
     if (acquisition.stream === undefined)
         return acquisition.retryAfterMs === undefined
             ? Object.freeze(shared)

package/dist/internal/observation-kernel.d.ts

@@ -4,6 +4,8 @@ import type { SqliteOwner } from "./contracts.js";
 /** Finite process-local signal; durable owner state remains authoritative. */
 export type ObservationSignal = "closed" | "reset" | "durable" | "activity" | "progress";
 export type ObservationReason = "durable" | "activity" | "progress" | "settlement";
+/** Actual live-view demand, excluding exact-command settlement waiters. */
+export declare function hasOwnerObservers(store: SqliteOwner, sessionId: string): boolean;
 /** One scoped process-local observation registration. */
 export type ObservationRegistration = Readonly<{
     /** Inspect and consume one pending finite signal without waiting. */

package/dist/internal/observation-kernel.js

@@ -4,6 +4,13 @@ import { reportCatchFailure } from "./failure.js";
 const MAX_OBSERVATIONS = 64;
 const MAX_PENDING_HINTS = 256;
 const ownerPublishers = new WeakMap();
+/** Actual live-view demand, excluding exact-command settlement waiters. */
+export function hasOwnerObservers(store, sessionId) {
+    for (const publisher of ownerPublishers.get(store) ?? [])
+        if (publisher.observes(sessionId))
+            return true;
+    return false;
+}
 /** Combine coalesced reasons without allowing a progress hint to hide a commit. */
 export function mergeObservationSignals(first, second) {
     if (first === "closed" || second === "closed")
@@ -55,9 +62,9 @@ export function publishOwnerObservation(store, sessionId, reason = "durable") {
     const publishers = ownerPublishers.get(store);
     if (publishers === undefined)
         return;
-    for (const publish of publishers) {
+    for (const publisher of publishers) {
         try {
-            publish({ kind: "session", sessionId, reason });
+            publisher.publish({ kind: "session", sessionId, reason });
         }
         catch (cause) {
             reportCatchFailure("owner-observation-publish", cause);
@@ -70,9 +77,9 @@ export function publishAgentExecutionChange(store) {
     const publishers = ownerPublishers.get(store);
     if (publishers === undefined)
         return;
-    for (const publish of publishers) {
+    for (const publisher of publishers) {
         try {
-            publish({ kind: "agent-execution" });
+            publisher.publish({ kind: "agent-execution" });
         }
         catch (cause) {
             reportCatchFailure("owner-execution-change-publish", cause);
@@ -140,7 +147,11 @@ export function openObservationKernel(store) {
             deliverObservation(listener, publication.reason === "settlement" ? "durable" : publication.reason);
         }
     };
-    publishers.add(publish);
+    const publisher = {
+        publish,
+        observes: (sessionId) => [...(sessions.get(sessionId) ?? [])].some((listener) => !listener.closed && !listener.settlementOnly),
+    };
+    publishers.add(publisher);
     ownerPublishers.set(store, publishers);
     return Object.freeze({
         register: (sessionId, interest) => Effect.suspend(() => {
@@ -194,7 +205,7 @@ export function openObservationKernel(store) {
             if (released)
                 return;
             released = true;
-            publishers.delete(publish);
+            publishers.delete(publisher);
             if (publishers.size === 0)
                 ownerPublishers.delete(store);
             for (const listener of active)

package/dist/internal/promise-facade.js

@@ -139,6 +139,8 @@ function liftOptions(options, runtime) {
         Object.assign(base, { meta: options.meta });
     if (options.storagePressure !== undefined)
         Object.assign(base, { storagePressure: options.storagePressure });
+    if (options.admission !== undefined)
+        Object.assign(base, { admission: options.admission });
     if (options.compaction !== undefined)
         Object.assign(base, { compaction: options.compaction });
     const toolSource = options.tools;

package/dist/internal/run-scope.d.ts

@@ -1,4 +1,5 @@
 import type { FileTool } from "@fungi.computer/knapsack";
+import { type MuleError } from "@fungi.computer/mule/effect";
 import type { ModuleRegistration } from "@fungi.computer/mycelium";
 import * as Effect from "effect/Effect";
 import { ShiitakeError } from "../errors.js";
@@ -17,6 +18,19 @@ export declare class ToolSetupError extends ShiitakeError {
     constructor(phase: keyof typeof toolSetupMessages);
     get diagnostic(): string;
 }
+/** Closed reasons a rejected run names, never a foreign error's own text. */
+declare const runRejectedDiagnostics: {
+    readonly model: "model-failed";
+    readonly tool: "tool-failed";
+    readonly control: "control-failed";
+    readonly listener: "listener-failed";
+};
+/** A run Mule ended with a non-model error; it names a closed reason. */
+export declare class RunRejectedError extends ShiitakeError {
+    private readonly reason;
+    constructor(reason: keyof typeof runRejectedDiagnostics, underlying: MuleError);
+    get diagnostic(): string;
+}
 /** Run one accepted command with Pi compaction explicitly composed around Mule. */
 export declare function runAcceptedCommand(options: ShiitakeEffectOptions, prepared: PreparedSessionRun, executionContract: RunContract, extensionModules: readonly ModuleRegistration[], extensionFileTools: readonly FileTool[], compactionHandoff: CompactionHandoffV0 | undefined, promptSections?: () => Effect.Effect<readonly PromptSectionV0[], ShiitakeError>): Effect.Effect<{
     run: import("@fungi.computer/mule/effect").MuleRunOutcome;