@fungi.computer/shiitake 0.1.0 → 0.3.0

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

@@ -4,7 +4,7 @@ import type { SqliteOwner } from "../contracts.js";
 export declare function prepareSessionAttention(owner: SqliteOwner): void;
 /** Read the complete bounded attention projection inside the owner's transaction. */
 export declare function readSessionAttention(owner: SqliteOwner, sessionId: string): readonly SessionAttention[];
-/** Whether any owner still requests attention; no wall-clock expiry heuristic. */
+/** Whether any owner requests inbox attention; drawer-only items stay visible. */
 export declare function hasSessionAttention(owner: SqliteOwner, sessionId: string): boolean;
 /** Upsert only the calling extension's item, in the calling transaction. */
 export declare function setSessionAttention(owner: SqliteOwner, sessionId: string, extensionId: string, item: AttentionItem): void;

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

@@ -32,10 +32,10 @@ export function readSessionAttention(owner, sessionId) {
         });
     });
 }
-/** Whether any owner still requests attention; no wall-clock expiry heuristic. */
+/** Whether any owner requests inbox attention; drawer-only items stay visible. */
 export function hasSessionAttention(owner, sessionId) {
     return (owner.sql
-        .exec("SELECT 1 FROM session_attention a JOIN shiitake_extension_status s ON s.extension_id = a.extension_id AND s.status = 'running' JOIN session_attention_grants g ON g.extension_id = a.extension_id WHERE a.session_id = ? LIMIT 1", sessionId)
+        .exec("SELECT 1 FROM session_attention a JOIN shiitake_extension_status s ON s.extension_id = a.extension_id AND s.status = 'running' JOIN session_attention_grants g ON g.extension_id = a.extension_id WHERE a.session_id = ? AND json_extract(a.value_json, '$.inbox') IS NOT 0 LIMIT 1", sessionId)
         .toArray().length > 0);
 }
 /** Upsert only the calling extension's item, in the calling transaction. */

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

@@ -1,10 +1,13 @@
-import type { Message, MuleIdentity, MuleToolResult, ToolCall, Usage, UserMessage } from "@fungi.computer/mule/effect";
+import type { ModelMessage } from "../../client.js";
+import type { ImageContent, JsonValue, MuleIdentity, TextContent, ToolCall, Usage, UserMessage } from "@fungi.computer/mule/effect";
 import * as Schema from "effect/Schema";
 import * as Result from "effect/Result";
+/** An archive owner's opaque receipt: a non-empty string of at most 4096 bytes. */
+export declare const CompactionReceiptSchema: Schema.String;
 /** Provider-native usage grammar shared by stored messages and settlement facts. */
 export declare const usage: Schema.Codec<Usage>;
-/** Exact Pi message grammar stored by Woodstock without normalization. */
-export declare const StoredPiMessageSchema: Schema.Codec<Message>;
+/** Model content only; application data is carried by the surrounding entry. */
+export declare const StoredPiMessageSchema: Schema.Codec<ModelMessage>;
 declare const LiveRetryEventSchema: Schema.Union<readonly [Schema.Struct<{
     readonly type: Schema.Literal<"auto_retry_start">;
     readonly run: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
@@ -44,7 +47,7 @@ declare const StoredSessionEntrySchema: Schema.Union<readonly [Schema.Struct<{
         readonly executionId: Schema.String;
         readonly adapter: Schema.String;
         readonly buildSha: Schema.NullOr<Schema.String>;
-        readonly tag: Schema.Literals<readonly ["SourceInvalid", "GuestThrew", "DeadlineExceeded", "Cancelled", "DispatchLost", "SandboxCrashed", "BadResponse", "ResultTooLarge", "ResultNotJson", "CapabilityFailed", "Unknown"]>;
+        readonly tag: Schema.Literals<readonly ["SourceInvalid", "GuestThrew", "DeadlineExceeded", "SandboxBusy", "Cancelled", "DispatchLost", "SandboxCrashed", "BadResponse", "ResultTooLarge", "ResultNotJson", "CapabilityFailed", "Unknown"]>;
         readonly fields: Schema.$Record<Schema.String, Schema.Codec<import("zod").JSONType, import("zod").JSONType, never, never>>;
         readonly healthAlert: Schema.Boolean;
     }>;
@@ -157,10 +160,11 @@ declare const StoredSessionEntrySchema: Schema.Union<readonly [Schema.Struct<{
     readonly workId: Schema.String;
 }>, Schema.Struct<{
     readonly kind: Schema.Literal<"message">;
+    readonly data: Schema.optionalKey<Schema.Codec<JsonValue, JsonValue, never, never>>;
     readonly run: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
     readonly turn: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
     readonly message: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
-    readonly value: Schema.Codec<Message, Message, never, never>;
+    readonly value: Schema.Codec<ModelMessage, ModelMessage, never, never>;
     readonly workId: Schema.String;
 }>, Schema.Struct<{
     readonly kind: Schema.Literal<"tool_intent">;
@@ -176,11 +180,17 @@ declare const StoredSessionEntrySchema: Schema.Union<readonly [Schema.Struct<{
     readonly workId: Schema.String;
 }>, Schema.Struct<{
     readonly kind: Schema.Literal<"tool_outcome">;
+    readonly data: Schema.optionalKey<Schema.Codec<JsonValue, JsonValue, never, never>>;
     readonly run: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
     readonly turn: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
     readonly toolCall: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
     readonly call: Schema.Codec<ToolCall, ToolCall, never, never>;
-    readonly result: Schema.Codec<MuleToolResult, MuleToolResult, never, never>;
+    readonly result: Schema.Struct<{
+        readonly content: Schema.mutable<Schema.$Array<Schema.Union<readonly [Schema.Codec<TextContent, TextContent, never, never>, Schema.Codec<ImageContent, ImageContent, never, never>]>>>;
+        readonly usage: Schema.optional<Schema.Codec<Usage, Usage, never, never>>;
+        readonly isError: Schema.Boolean;
+        readonly terminate: Schema.optional<Schema.Boolean>;
+    }>;
     readonly workId: Schema.String;
 }>, Schema.Struct<{
     readonly kind: Schema.Literal<"live_retry">;
@@ -205,30 +215,57 @@ declare const StoredSessionEntrySchema: Schema.Union<readonly [Schema.Struct<{
     readonly workId: Schema.String;
 }>, Schema.Struct<{
     readonly kind: Schema.Literal<"compaction">;
-    readonly resumesRun: Schema.optionalKey<Schema.Boolean>;
-    readonly trigger: Schema.optionalKey<Schema.Literals<readonly ["manual", "threshold", "overflow"]>>;
-    /** Estimated context tokens right after this compaction. */
-    readonly tokensAfter: Schema.optionalKey<Schema.Number>;
-    readonly firstKeptEntryId: Schema.String;
-    readonly summary: Schema.String;
-    readonly tokensBefore: Schema.Number;
-    readonly usage: Schema.Codec<Usage, Usage, never, never>;
-    readonly contextRevision: Schema.String;
-    readonly details: Schema.optionalKey<Schema.Struct<{
-        readonly readFiles: Schema.$Array<Schema.String>;
-        readonly modifiedFiles: Schema.$Array<Schema.String>;
-    }>>;
+    readonly head: Schema.String;
+    readonly model: Schema.Tuple<readonly [Schema.Codec<UserMessage, UserMessage, never, never>]>;
+    readonly data: Schema.Struct<{
+        readonly reason: Schema.optionalKey<Schema.Literals<readonly ["manual", "threshold", "overflow"]>>;
+        readonly resumesRun: Schema.Boolean;
+        readonly tokensBefore: Schema.Number;
+        /** Estimated context tokens right after this compaction. */
+        readonly tokensAfter: Schema.optionalKey<Schema.Number>;
+        readonly usage: Schema.Codec<Usage, Usage, never, never>;
+        readonly contextRevision: Schema.String;
+        /**
+         * The archive owner's opaque receipt for this compaction, committed in
+         * the same append as the transition. Absent when no handoff archived it.
+         */
+        readonly receipt: Schema.optionalKey<Schema.String>;
+        readonly details: Schema.optionalKey<Schema.Struct<{
+            readonly readFiles: Schema.$Array<Schema.String>;
+            readonly modifiedFiles: Schema.$Array<Schema.String>;
+        }>>;
+    }>;
+    readonly workId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"compaction_notice">;
+    readonly trigger: Schema.Literals<readonly ["manual", "threshold", "overflow"]>;
+    readonly result: Schema.Literal<"nothing_to_compact">;
+    readonly diagnostic: Schema.optionalKey<Schema.String>;
     readonly workId: Schema.String;
 }>, Schema.Struct<{
     readonly kind: Schema.Literal<"compaction_notice">;
     readonly trigger: Schema.Literals<readonly ["manual", "threshold", "overflow"]>;
-    readonly result: Schema.Literals<readonly ["nothing_to_compact", "failed"]>;
+    readonly result: Schema.Literal<"failed">;
+    readonly usage: Schema.optionalKey<Schema.Codec<Usage, Usage, never, never>>;
     readonly diagnostic: Schema.optionalKey<Schema.String>;
     readonly workId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"compaction_notice">;
+    readonly trigger: Schema.Literals<readonly ["manual", "threshold", "overflow"]>;
+    readonly result: Schema.Literal<"stale">;
+    readonly usage: Schema.optionalKey<Schema.Codec<Usage, Usage, never, never>>;
+    readonly workId: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"compaction_notice">;
+    readonly trigger: Schema.Literals<readonly ["manual", "threshold", "overflow"]>;
+    readonly result: Schema.Literal<"insufficient">;
+    readonly usage: Schema.optionalKey<Schema.Codec<Usage, Usage, never, never>>;
+    readonly workId: Schema.String;
 }>, Schema.Struct<{
     readonly kind: Schema.Literal<"run_terminal">;
     readonly run: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
     readonly terminal: Schema.Codec<MuleIdentity, MuleIdentity, never, never>;
+    readonly diagnostic: Schema.optionalKey<Schema.String>;
     readonly outcome: Schema.Literals<readonly ["completed", "cancelled", "failed"]>;
     readonly workId: Schema.String;
 }>, Schema.Struct<{
@@ -271,7 +308,7 @@ export declare function commandContextMessage(entry: PromptCommandEntry): UserMe
  * What a client sees of an operator line: the party's words as a user
  * message, the operator's as an assistant message from provider `operator`.
  */
-export declare function operatorClientMessage(entry: OperatorSessionEntry): Message;
+export declare function operatorClientMessage(entry: OperatorSessionEntry): ModelMessage;
 /** Decode the one JSON representation admitted by retained Session storage. */
 export declare function decodeStoredSessionEntry(value: string): Result.Result<{
     readonly kind: "sandbox_failure";
@@ -281,7 +318,7 @@ export declare function decodeStoredSessionEntry(value: string): Result.Result<{
         readonly executionId: string;
         readonly adapter: string;
         readonly buildSha: string | null;
-        readonly tag: "Unknown" | "SourceInvalid" | "GuestThrew" | "DeadlineExceeded" | "Cancelled" | "DispatchLost" | "SandboxCrashed" | "BadResponse" | "ResultTooLarge" | "ResultNotJson" | "CapabilityFailed";
+        readonly tag: "Unknown" | "SourceInvalid" | "GuestThrew" | "DeadlineExceeded" | "SandboxBusy" | "Cancelled" | "DispatchLost" | "SandboxCrashed" | "BadResponse" | "ResultTooLarge" | "ResultNotJson" | "CapabilityFailed";
         readonly fields: {
             readonly [x: string]: import("zod").JSONType;
         };
@@ -395,10 +432,11 @@ export declare function decodeStoredSessionEntry(value: string): Result.Result<{
 } | {
     readonly kind: "message";
     readonly run: MuleIdentity;
-    readonly turn: MuleIdentity;
     readonly message: MuleIdentity;
-    readonly value: Message;
     readonly workId: string;
+    readonly value: ModelMessage;
+    readonly turn: MuleIdentity;
+    readonly data?: JsonValue;
 } | {
     readonly kind: "tool_intent";
     readonly replay: "unsafe" | "safe";
@@ -414,11 +452,17 @@ export declare function decodeStoredSessionEntry(value: string): Result.Result<{
 } | {
     readonly kind: "tool_outcome";
     readonly run: MuleIdentity;
+    readonly workId: string;
+    readonly call: ToolCall;
     readonly turn: MuleIdentity;
     readonly toolCall: MuleIdentity;
-    readonly call: ToolCall;
-    readonly result: MuleToolResult;
-    readonly workId: string;
+    readonly result: {
+        readonly content: (TextContent | ImageContent)[];
+        readonly isError: boolean;
+        readonly usage?: Usage | undefined;
+        readonly terminate?: boolean | undefined;
+    };
+    readonly data?: JsonValue;
 } | {
     readonly kind: "live_retry";
     readonly event: {
@@ -442,31 +486,54 @@ export declare function decodeStoredSessionEntry(value: string): Result.Result<{
     readonly workId: string;
 } | {
     readonly kind: "compaction";
-    readonly summary: string;
-    readonly workId: string;
-    readonly usage: Usage;
-    readonly firstKeptEntryId: string;
-    readonly tokensBefore: number;
-    readonly contextRevision: string;
-    readonly resumesRun?: boolean;
-    readonly trigger?: "manual" | "threshold" | "overflow";
-    readonly tokensAfter?: number;
-    readonly details?: {
-        readonly readFiles: readonly string[];
-        readonly modifiedFiles: readonly string[];
+    readonly head: string;
+    readonly model: readonly [UserMessage];
+    readonly data: {
+        readonly usage: Usage;
+        readonly resumesRun: boolean;
+        readonly tokensBefore: number;
+        readonly contextRevision: string;
+        readonly reason?: "manual" | "threshold" | "overflow";
+        readonly receipt?: string;
+        readonly details?: {
+            readonly readFiles: readonly string[];
+            readonly modifiedFiles: readonly string[];
+        };
+        readonly tokensAfter?: number;
     };
+    readonly workId: string;
 } | {
     readonly kind: "compaction_notice";
     readonly workId: string;
-    readonly result: "failed" | "nothing_to_compact";
+    readonly result: "nothing_to_compact";
     readonly trigger: "manual" | "threshold" | "overflow";
     readonly diagnostic?: string;
+} | {
+    readonly kind: "compaction_notice";
+    readonly workId: string;
+    readonly result: "failed";
+    readonly trigger: "manual" | "threshold" | "overflow";
+    readonly usage?: Usage;
+    readonly diagnostic?: string;
+} | {
+    readonly kind: "compaction_notice";
+    readonly workId: string;
+    readonly result: "stale";
+    readonly trigger: "manual" | "threshold" | "overflow";
+    readonly usage?: Usage;
+} | {
+    readonly kind: "compaction_notice";
+    readonly workId: string;
+    readonly result: "insufficient";
+    readonly trigger: "manual" | "threshold" | "overflow";
+    readonly usage?: Usage;
 } | {
     readonly kind: "run_terminal";
     readonly run: MuleIdentity;
-    readonly terminal: MuleIdentity;
-    readonly outcome: "completed" | "failed" | "cancelled";
     readonly workId: string;
+    readonly outcome: "completed" | "failed" | "cancelled";
+    readonly terminal: MuleIdentity;
+    readonly diagnostic?: string;
 } | {
     readonly kind: "work_terminal";
     readonly workId: string;

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

@@ -10,6 +10,8 @@ const closed = { onExcessProperty: "error" };
 const encoder = new TextEncoder();
 const boundedText = (maximumBytes) => Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.makeFilter((value) => encoder.encode(value).byteLength <= maximumBytes)));
 const boundedId = boundedText(256);
+/** An archive owner's opaque receipt: a non-empty string of at most 4096 bytes. */
+export const CompactionReceiptSchema = boundedText(4096);
 const digest = Schema.String.pipe(Schema.check(Schema.isPattern(/^[0-9a-f]{64}$/u)));
 const jsonValue = Schema.suspend(() => Schema.Union([
     Schema.String,
@@ -42,6 +44,7 @@ const StoredToolCallSchema = Schema.Struct({
     arguments: Schema.Record(Schema.String, jsonValue),
     thoughtSignature: Schema.optionalKey(Schema.String),
     namespace: Schema.optionalKey(Schema.String),
+    argumentsError: Schema.optionalKey(Schema.String),
 });
 /** Provider-native usage grammar shared by stored messages and settlement facts. */
 export const usage = Schema.Struct({
@@ -148,18 +151,19 @@ const assistantMessage = Schema.Struct({
     providerThinkingLevel: Schema.optionalKey(Schema.String),
     endTurn: Schema.optionalKey(Schema.Boolean),
     timestamp: Schema.Number,
+    durationMs: Schema.optionalKey(Schema.Number),
 });
 const toolResultMessage = Schema.Struct({
     role: Schema.Literal("toolResult"),
     toolCallId: Schema.String,
     toolName: Schema.String,
     content: Schema.mutable(Schema.Array(Schema.Union([textContent, imageContent]))),
-    details: Schema.optionalKey(jsonValue),
     usage: Schema.optionalKey(usage),
     isError: Schema.Boolean,
     timestamp: Schema.Number,
+    durationMs: Schema.optionalKey(Schema.Number),
 });
-/** Exact Pi message grammar stored by Woodstock without normalization. */
+/** Model content only; application data is carried by the surrounding entry. */
 export const StoredPiMessageSchema = Schema.Union([
     systemMessage,
     userMessage,
@@ -212,7 +216,6 @@ const runContract = Schema.Struct({
 });
 const StoredToolResultSchema = Schema.Struct({
     content: Schema.mutable(Schema.Array(Schema.Union([textContent, imageContent]))),
-    details: Schema.optional(jsonValue),
     usage: Schema.optional(usage),
     isError: Schema.Boolean,
     terminate: Schema.optional(Schema.Boolean),
@@ -327,6 +330,7 @@ const StoredSessionEntrySchema = Schema.Union([
     Schema.Struct({
         ...common,
         kind: Schema.Literal("message"),
+        data: Schema.optionalKey(jsonValue),
         run: CausalIdentitySchema,
         turn: CausalIdentitySchema,
         message: CausalIdentitySchema,
@@ -345,6 +349,7 @@ const StoredSessionEntrySchema = Schema.Union([
     Schema.Struct({
         ...common,
         kind: Schema.Literal("tool_outcome"),
+        data: Schema.optionalKey(jsonValue),
         run: CausalIdentitySchema,
         turn: CausalIdentitySchema,
         toolCall: CausalIdentitySchema,
@@ -356,39 +361,77 @@ const StoredSessionEntrySchema = Schema.Union([
         kind: Schema.Literal("live_retry"),
         event: LiveRetryEventSchema,
     }),
+    // Pi Durable's compaction entry (`compaction.ts`): the summary is the
+    // user message the model reads, and `head` names the first kept entry.
+    // Clients render a divider from `data` and never show the summary.
     Schema.Struct({
         ...common,
         kind: Schema.Literal("compaction"),
-        resumesRun: Schema.optionalKey(Schema.Boolean),
-        // Optional only because Sessions compacted before these facts existed
-        // are still live; every new compaction records both.
-        trigger: Schema.optionalKey(CompactionTriggerSchema),
-        /** Estimated context tokens right after this compaction. */
-        tokensAfter: Schema.optionalKey(Schema.Number),
-        firstKeptEntryId: boundedId,
-        summary: Schema.String,
-        tokensBefore: Schema.Number,
-        usage,
-        contextRevision: boundedId,
-        details: Schema.optionalKey(Schema.Struct({
-            readFiles: Schema.Array(Schema.String),
-            modifiedFiles: Schema.Array(Schema.String),
-        })),
+        head: boundedId,
+        model: Schema.Tuple([userMessage]),
+        data: Schema.Struct({
+            // Absent only on rows from before these facts were recorded; the
+            // store rewrite never invents them, and every new row has both.
+            reason: Schema.optionalKey(CompactionTriggerSchema),
+            resumesRun: Schema.Boolean,
+            tokensBefore: Schema.Number,
+            /** Estimated context tokens right after this compaction. */
+            tokensAfter: Schema.optionalKey(Schema.Number),
+            usage,
+            contextRevision: boundedId,
+            /**
+             * The archive owner's opaque receipt for this compaction, committed in
+             * the same append as the transition. Absent when no handoff archived it.
+             */
+            receipt: Schema.optionalKey(CompactionReceiptSchema),
+            details: Schema.optionalKey(Schema.Struct({
+                readFiles: Schema.Array(Schema.String),
+                modifiedFiles: Schema.Array(Schema.String),
+            })),
+        }),
     }),
     // A compaction that committed nothing: a manual request with nothing to
-    // summarize, or any compaction that failed. Clients show it as a result.
+    // summarize, any compaction that failed, or a finished summary dropped
+    // unplaced: stale (its head is off the selected lineage or older than the
+    // context start) or insufficient (placed, the context would still be over
+    // the limit). A completed summary keeps its `usage`, including when its
+    // handoff fails. Nothing to compact still refuses usage. Clients show each
+    // as a result.
     Schema.Struct({
         ...common,
         kind: Schema.Literal("compaction_notice"),
         trigger: CompactionTriggerSchema,
-        result: Schema.Literals(["nothing_to_compact", "failed"]),
+        result: Schema.Literal("nothing_to_compact"),
         diagnostic: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(200))),
     }),
+    Schema.Struct({
+        ...common,
+        kind: Schema.Literal("compaction_notice"),
+        trigger: CompactionTriggerSchema,
+        result: Schema.Literal("failed"),
+        usage: Schema.optionalKey(usage),
+        diagnostic: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(200))),
+    }),
+    Schema.Struct({
+        ...common,
+        kind: Schema.Literal("compaction_notice"),
+        trigger: CompactionTriggerSchema,
+        result: Schema.Literal("stale"),
+        usage: Schema.optionalKey(usage),
+    }),
+    Schema.Struct({
+        ...common,
+        kind: Schema.Literal("compaction_notice"),
+        trigger: CompactionTriggerSchema,
+        result: Schema.Literal("insufficient"),
+        usage: Schema.optionalKey(usage),
+    }),
     Schema.Struct({
         ...common,
         kind: Schema.Literal("run_terminal"),
         run: CausalIdentitySchema,
         terminal: CausalIdentitySchema,
+        diagnostic: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(200))),
         outcome: Schema.Literals(["completed", "cancelled", "failed"]),
     }),
     Schema.Struct({

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

@@ -102,6 +102,8 @@ export function prepareSessionInbox(owner) {
        ON session_inbox(tier, last_activity_at DESC, session_id)`);
     owner.sql.exec(`CREATE INDEX IF NOT EXISTS idx_session_inbox_revision
        ON session_inbox(revision)`);
+    owner.sql.exec(`CREATE INDEX IF NOT EXISTS idx_session_inbox_coldest
+       ON session_inbox(last_activity_at, session_id)`);
     owner.sql.exec(`
     CREATE TABLE IF NOT EXISTS session_inbox_clock (
       singleton INTEGER PRIMARY KEY CHECK (singleton = 1),