@fungi.computer/shiitake 0.0.1 → 0.1.0

package/dist/agent-control.d.ts

@@ -36,11 +36,16 @@ export type AgentControlDirectory = Readonly<{
     list: (signal: AbortSignal) => Promise<readonly AgentControlAgent[]>;
     /** Follow-up delegation with durable replies to the invoking Session. */
     send?: (input: AgentDelegationInput, sourceSessionId: string, signal: AbortSignal, invocation?: AgentDelegationInvocation) => Promise<Accepted>;
-    /** Present only when this host authorizes ordinary Agent creation. */
+    /**
+     * Present only when this host authorizes ordinary Agent creation. `invoker`
+     * names the Session whose run asked, so a host can record provenance.
+     */
     create?: (input: Readonly<{
         requestId: string;
         model?: ModelPreference;
-    }>, signal: AbortSignal) => Promise<AgentControlAgent>;
+    }>, signal: AbortSignal, invoker?: Readonly<{
+        sessionId: string;
+    }>) => Promise<AgentControlAgent>;
     /** Present only when the host authorizes changing an Agent's future default. */
     setModel?: (input: Readonly<{
         agentId: string;

package/dist/agent-control.js

@@ -235,7 +235,7 @@ function admitModelRefusal(operation, cause) {
 /** Compose one authorized Agent-control projection for a single run lease. */
 export function createAgentControlSource(directory) {
     const create = directory.create;
-    const createOperation = create === undefined
+    const createOperation = (session) => create === undefined
         ? undefined
         : Mycelium.operation({
             replay: "unsafe",
@@ -244,9 +244,10 @@ export function createAgentControlSource(directory) {
             output: agentOutput,
             execute: async ({ requestId, model }, context) => agentOutput.parse(await create(model === undefined
                 ? { requestId }
-                : { requestId, model: parseModelAddress(model) }, context.signal).catch((cause) => admitModelRefusal("create", cause))),
+                : { requestId, model: parseModelAddress(model) }, context.signal, session === undefined
+                ? undefined
+                : { sessionId: session.sessionId }).catch((cause) => admitModelRefusal("create", cause))),
         });
-    const createOperations = createOperation === undefined ? {} : { create: createOperation };
     const setModel = directory.setModel;
     const modelOperations = setModel === undefined
         ? {}
@@ -287,6 +288,8 @@ export function createAgentControlSource(directory) {
         acquire: ({ signal, session }) => {
             signal.throwIfAborted();
             const sends = new WeakMap();
+            const created = createOperation(session);
+            const createOperations = created === undefined ? {} : { create: created };
             return Promise.resolve({
                 snapshot: {
                     version: "shiitake-agent-control-v6",

package/dist/fleet.d.ts

@@ -231,6 +231,17 @@ export declare function delegationSendMeta(sender: FungiAuthor, invocationMeta?:
  * its author, and the verified reply rides beside the caller's own path.
  */
 export declare function delegationReplyMeta(delegation: AuthenticatedDelegationReply, replierName: string): DelegationReplyMeta;
+/** One Agent a Session sent work to: its latest addressed conversation. */
+export type FleetRecipient = Readonly<{
+    agentId: string;
+    sessionId: string;
+    sentAt: number;
+}>;
+/** A bounded page of recipients and how many more exist past it. */
+export type FleetRecipients = Readonly<{
+    recipients: readonly FleetRecipient[];
+    more: number;
+}>;
 /**
  * Hosted BirdDog submission and Pending observation. The durable row freezes
  * correspondence before transport; an ambiguous delivery reuses that exact mail.
@@ -239,6 +250,11 @@ export declare function delegationReplyMeta(delegation: AuthenticatedDelegationR
 export declare function createFleetDelegation(options: FleetDelegationOptions): {
     /** Authenticate a reply against its frozen mail and restore the caller's path. */
     authenticateReply: (mail: BirdDogMail) => AuthenticatedDelegationReply | undefined;
+    /** One grouped read of the Agents a parent Session sent work to. */
+    recipients: (parent: Readonly<{
+        agentId: string;
+        sessionId: string;
+    }>, limit: number) => FleetRecipients;
     /** Submit once and return the existing Shiitake admission receipt. */
     start: (grant: AgentGrant, raw: AgentDelegationTask) => Promise<Accepted>;
     /** Submit or poll the exact turn, yielding Agar Pending until settled. */

package/dist/fleet.js

@@ -324,6 +324,12 @@ const delegationRowSchema = z.strictObject({
     receipt: z.string().nullable(),
 });
 const decodeMail = Schema.decodeUnknownSync(Schema.fromJsonString(BirdDogMailSchema));
+const recipientRowSchema = z.strictObject({
+    agent_id: identity,
+    session_id: identity,
+    sent_at: z.number().int().nonnegative(),
+    total: z.number().int().nonnegative(),
+});
 /**
  * Hosted BirdDog submission and Pending observation. The durable row freezes
  * correspondence before transport; an ambiguous delivery reuses that exact mail.
@@ -464,9 +470,28 @@ export function createFleetDelegation(options) {
             reply,
         };
     }
+    /**
+     * The distinct Agents one parent Session sent work to, newest send first,
+     * with how many more exist past `limit`. Read-only over the frozen mail.
+     */
+    function recipients(parent, limit) {
+        const rows = store
+            .recipients(parent.agentId, parent.sessionId, limit)
+            .map((row) => recipientRowSchema.parse(row));
+        return {
+            recipients: rows.map((row) => ({
+                agentId: row.agent_id,
+                sessionId: row.session_id,
+                sentAt: row.sent_at,
+            })),
+            more: Math.max(0, (rows[0]?.total ?? 0) - rows.length),
+        };
+    }
     return {
         /** Authenticate a reply against its frozen mail and restore the caller's path. */
         authenticateReply,
+        /** One grouped read of the Agents a parent Session sent work to. */
+        recipients,
         /** Submit once and return the existing Shiitake admission receipt. */
         start,
         /** Submit or poll the exact turn, yielding Agar Pending until settled. */

package/dist/internal/admission-door.js

@@ -20,7 +20,7 @@ function decodeReply(request) {
         mail.from.agentId !== reply.agentId ||
         mail.from.sessionId !== reply.sessionId ||
         request.command.type !== "prompt" ||
-        request.command.delivery !== "followUp")
+        request.command.delivery !== "steer")
         throw new ShiitakeError("contract", "invalid", "Verified Agent reply does not match its mail");
     return reply;
 }

package/dist/internal/compaction/compaction.d.ts

@@ -3,7 +3,7 @@
  * The retained preparation/result vocabulary is intentionally visible here;
  * Shiitake supplies native Message values and its selected model stream.
  */
-import { type Api, type Model, type Usage } from "@earendil-works/pi-ai";
+import type { Api, Model, Usage } from "@earendil-works/pi-ai";
 import type { MuleStreamFunction } from "@fungi.computer/mule/effect";
 import * as Effect from "effect/Effect";
 import type { BorrowedCompactionViewV0 } from "../../extensions.js";

package/dist/internal/compaction/compaction.js

@@ -1,9 +1,8 @@
-/**
- * Pi v0.84.4 semantic compaction, adapted only at Woodstock's entry boundary.
- * The retained preparation/result vocabulary is intentionally visible here;
- * Shiitake supplies native Message values and its selected model stream.
- */
-import { contentText, normalizeContext, retryAssistantCall, uuidv7, } from "@earendil-works/pi-ai";
+// Leaf helpers, not Pi's root entry, which also evaluates its validators.
+import { retryAssistantCall } from "@earendil-works/pi-ai/utils/retry";
+import { contentText } from "@earendil-works/pi-ai/utils/text";
+import { normalizeContext } from "@earendil-works/pi-ai/utils/transcript";
+import { uuidv7 } from "@earendil-works/pi-ai/utils/uuid";
 import * as Effect from "effect/Effect";
 import { ShiitakeError } from "../../errors.js";
 import { computeFileLists, createFileOps, extractFileOpsFromMessage, formatFileOperations, serializeConversation, SUMMARIZATION_PROMPT, SUMMARIZATION_SYSTEM_PROMPT, TURN_PREFIX_SUMMARIZATION_PROMPT, UPDATE_SUMMARIZATION_PROMPT, compactionSummaryMessage, estimateContextTokens, estimateTokens, summaryFailure, } from "./utils.js";

package/dist/internal/compaction/session-compaction.js

@@ -1,5 +1,5 @@
 import { isContextOverflow, } from "@fungi.computer/mule/effect";
-import { isRecoverableLength } from "@earendil-works/pi-ai";
+import { isRecoverableLength } from "@earendil-works/pi-ai/utils/overflow";
 import * as Effect from "effect/Effect";
 import { ShiitakeError } from "../../errors.js";
 import { borrowedView, compact, prepareCompaction, } from "./compaction.js";

package/dist/internal/coordinator.js

@@ -355,7 +355,7 @@ export function openCoordinator(options, runtime) {
 export function acceptAddressedMail(runtime, mail, meta, reply) {
     return admitUserWork(runtime, mail.to.sessionId, {
         requestId: mail.key,
-        delivery: "followUp",
+        delivery: reply === undefined ? "followUp" : "steer",
         type: "prompt",
         text: mail.content,
     }, meta, mail, reply);

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

@@ -27,6 +27,10 @@ export declare function createFleetDelegationStore(storage: WatchdogSqliteOwner)
     read: (requestId: string) => {
         readonly [x: string]: string | number | ArrayBuffer | null;
     } | undefined;
+    /** Distinct addressed Agents of one parent Session, newest send first. */
+    recipients: (parentAgentId: string, parentSessionId: string, limit: number) => readonly {
+        readonly [x: string]: string | number | ArrayBuffer | null;
+    }[];
     reserve(requestId: string, input: string, mail: string): void;
     recordReceipt(requestId: string, receipt: string): void;
 };

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

@@ -70,15 +70,22 @@ export function createFleetDirectoryStore(sql) {
         return row?.complete === 1;
     }
 }
+const fromAgent = "json_extract(mail, '$.from.agentId')";
+const fromSession = "json_extract(mail, '$.from.sessionId')";
 /** Durable correspondence is frozen before delivery; retries reuse the same row. */
 export function createFleetDelegationStore(storage) {
     storage.sql.exec(`CREATE TABLE IF NOT EXISTS shiitake_fleet_delegations (
     request_id TEXT PRIMARY KEY, input TEXT NOT NULL, mail TEXT NOT NULL, receipt TEXT
   ) STRICT`);
+    storage.sql.exec(`CREATE INDEX IF NOT EXISTS idx_shiitake_fleet_delegations_parent ON shiitake_fleet_delegations(${fromAgent}, ${fromSession})`);
     return {
         read: (requestId) => storage.sql
             .exec("SELECT input, mail, receipt FROM shiitake_fleet_delegations WHERE request_id = ?", requestId)
             .toArray()[0],
+        /** Distinct addressed Agents of one parent Session, newest send first. */
+        recipients: (parentAgentId, parentSessionId, limit) => storage.sql
+            .exec(`SELECT json_extract(mail, '$.to.agentId') AS agent_id, json_extract(mail, '$.to.sessionId') AS session_id, MAX(json_extract(mail, '$.createdAt')) AS sent_at, COUNT(*) OVER () AS total FROM shiitake_fleet_delegations WHERE ${fromAgent} = ? AND ${fromSession} = ? GROUP BY agent_id ORDER BY sent_at DESC, agent_id LIMIT ?`, parentAgentId, parentSessionId, limit)
+            .toArray(),
         reserve(requestId, input, mail) {
             storage.transactionSync(() => {
                 storage.sql.exec("INSERT OR IGNORE INTO shiitake_fleet_delegations(request_id, input, mail) VALUES (?, ?, ?)", requestId, input, mail);

package/docs/api/agent-control.md

@@ -72,7 +72,7 @@ Host-only identity and admitted command metadata for one delegated send.
 type AgentControlDirectory = Readonly<{
   list: (signal) => Promise<readonly AgentControlAgent[]>;
   send?: (input, sourceSessionId, signal, invocation?) => Promise<Accepted>;
-  create?: (input, signal) => Promise<AgentControlAgent>;
+  create?: (input, signal, invoker?) => Promise<AgentControlAgent>;
   setModel?: (input, signal) => Promise<void>;
   models?: (signal) => Promise<readonly AgentControlModel[]>;
   checkModel?: (input, signal) => Promise<void>;

package/docs/api/effect.md

@@ -535,26 +535,6 @@ for it. An unreadable Session is its own `unavailable` row.
 [`StoredSessionSummaryRow`](#storedsessionsummaryrow)[]; `next`: `string` \|
 `undefined`; \}\>, [`ShiitakeError`](index.md#shiitakeerror), `never`\>
 
----
-
-### inspectWoodstockStoreProtocol()
-
-```ts
-function inspectWoodstockStoreProtocol(owner): "fresh" | "v0" | "unmarked";
-```
-
-Inspect one unopened store before the file-backed host takes custody.
-
-#### Parameters
-
-| Parameter | Type                                  |
-| --------- | ------------------------------------- |
-| `owner`   | [`SqliteOwner`](index.md#sqliteowner) |
-
-#### Returns
-
-`"fresh"` \| `"v0"` \| `"unmarked"`
-
 ## References
 
 ### AbortCommand

package/docs/api/fleet.md

@@ -303,6 +303,33 @@ The host metadata on one authenticated reply line, as JSON.
 
 ---
 
+### FleetRecipient
+
+```ts
+type FleetRecipient = Readonly<{
+  agentId: string;
+  sessionId: string;
+  sentAt: number;
+}>;
+```
+
+One Agent a Session sent work to: its latest addressed conversation.
+
+---
+
+### FleetRecipients
+
+```ts
+type FleetRecipients = Readonly<{
+  recipients: readonly FleetRecipient[];
+  more: number;
+}>;
+```
+
+A bounded page of recipients and how many more exist past it.
+
+---
+
 ### FleetAgentAccess
 
 ```ts
@@ -675,6 +702,7 @@ Shiitake owns work deduplication, execution and settlement; Post owns replies.
 | Name                  | Type                                                                                                                                                                                                                                                                                                                     | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
 | --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `authenticateReply()` | (`mail`) => \| `Readonly`\<\{ `ancestors`: readonly `string`[]; `maxDepth`: `number`; `reply`: \{ `commandId`: `string`; `outcome`: `"completed"` \| `"failed"` \| `"cancelled"` \| `"interrupted"` \| `"outcome_unknown"`; `diagnostic?`: `string`; `agentId`: `string`; `sessionId`: `string`; \}; \}\> \| `undefined` | Authenticate a reply against its frozen mail and restore the caller's path. Authenticate one arriving reply against the frozen mail this owner sent. It must be BirdDog's single reply key for that mail, mirror its sender and recipient exactly, carry BirdDog's settlement facts and, once the send's receipt is recorded, name that receipt's `commandId`. The result restores the caller's own delegation path and the verified reply; it never reads the reply's text or any settlement metadata. |
+| `recipients()`        | (`parent`, `limit`) => [`FleetRecipients`](#fleetrecipients)                                                                                                                                                                                                                                                             | One grouped read of the Agents a parent Session sent work to. The distinct Agents one parent Session sent work to, newest send first, with how many more exist past `limit`. Read-only over the frozen mail.                                                                                                                                                                                                                                                                                            |
 | `start()`             | (`grant`, `raw`) => `Promise`\<`Readonly`\<\{ `status`: `"accepted"`; `commandId`: `string`; \}\>\>                                                                                                                                                                                                                      | Submit once and return the existing Shiitake admission receipt.                                                                                                                                                                                                                                                                                                                                                                                                                                         |
 | `delegate()`          | (`grant`, `task`) => `Promise`\< \| `Readonly`\<\{ `kind`: `"pending"`; `retryAfterMs`: `number`; \}\> \| [`AgentDelegationOutcome`](#agentdelegationoutcome)\>                                                                                                                                                          | Submit or poll the exact turn, yielding Agar Pending until settled.                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fungi.computer/shiitake",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "author": "Levi <levi@technomancy.dev>",
   "description": "Effect-native durable Session acceptance and bounded run orchestration",
   "type": "module",
@@ -76,16 +76,16 @@
   "dependencies": {
     "@fungi.computer/bird-dog": "0.0.1",
     "@fungi.computer/cairn": "0.0.1",
-    "@fungi.computer/knapsack": "0.0.1",
-    "@fungi.computer/mule": "0.0.1",
-    "@fungi.computer/mycelium": "0.0.1",
+    "@fungi.computer/knapsack": "0.0.2",
+    "@fungi.computer/mule": "0.0.2",
+    "@fungi.computer/mycelium": "0.0.2",
     "@fungi.computer/watchdog": "0.0.1",
     "effect": "4.0.2",
     "hono": "4.13.5",
     "zod": "4.4.3",
     "@earendil-works/pi-ai": "0.99.2",
     "@fungi.computer/gills": "0.0.1",
-    "@fungi.computer/agar": "0.0.1"
+    "@fungi.computer/agar": "0.1.0"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "5.20260828.1",