@fungi.computer/shiitake 0.1.0 → 0.2.0

package/dist/agent-control.d.ts

@@ -36,16 +36,11 @@ 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. `invoker`
-     * names the Session whose run asked, so a host can record provenance.
-     */
+    /** Present only when this host authorizes ordinary Agent creation. */
     create?: (input: Readonly<{
         requestId: string;
         model?: ModelPreference;
-    }>, signal: AbortSignal, invoker?: Readonly<{
-        sessionId: string;
-    }>) => Promise<AgentControlAgent>;
+    }>, signal: AbortSignal) => 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 = (session) => create === undefined
+    const createOperation = create === undefined
         ? undefined
         : Mycelium.operation({
             replay: "unsafe",
@@ -244,10 +244,9 @@ export function createAgentControlSource(directory) {
             output: agentOutput,
             execute: async ({ requestId, model }, context) => agentOutput.parse(await create(model === undefined
                 ? { requestId }
-                : { requestId, model: parseModelAddress(model) }, context.signal, session === undefined
-                ? undefined
-                : { sessionId: session.sessionId }).catch((cause) => admitModelRefusal("create", cause))),
+                : { requestId, model: parseModelAddress(model) }, context.signal).catch((cause) => admitModelRefusal("create", cause))),
         });
+    const createOperations = createOperation === undefined ? {} : { create: createOperation };
     const setModel = directory.setModel;
     const modelOperations = setModel === undefined
         ? {}
@@ -288,8 +287,6 @@ 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

@@ -20,7 +20,7 @@ export declare const agentActionSchema: z.ZodEnum<{
 /** One host-admitted fleet operation. */
 export type AgentAction = z.infer<typeof agentActionSchema>;
 /** Attribution supplied by the admitting host, without Team semantics. */
-export declare const agentProvenanceSchema: z.ZodObject<{
+export declare const agentProvenanceSchema: z.ZodLazy<z.ZodObject<{
     actor: z.ZodString;
     workflowRunId: z.ZodOptional<z.ZodString>;
     toolCallInputDigest: z.ZodOptional<z.ZodString>;
@@ -28,9 +28,9 @@ export declare const agentProvenanceSchema: z.ZodObject<{
         agentId: z.ZodString;
         sessionId: z.ZodString;
     }, z.core.$strict>>;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** Fleet authority is supplied, never looked up in host policy. */
-export declare const agentGrantSchema: z.ZodObject<{
+export declare const agentGrantSchema: z.ZodLazy<z.ZodObject<{
     agents: z.ZodUnion<readonly [z.ZodLiteral<"all">, z.ZodArray<z.ZodString>]>;
     actions: z.ZodArray<z.ZodEnum<{
         send: "send";
@@ -40,7 +40,7 @@ export declare const agentGrantSchema: z.ZodObject<{
         delegate: "delegate";
     }>>;
     expiresAt: z.ZodNumber;
-    provenance: z.ZodObject<{
+    provenance: z.ZodLazy<z.ZodObject<{
         actor: z.ZodString;
         workflowRunId: z.ZodOptional<z.ZodString>;
         toolCallInputDigest: z.ZodOptional<z.ZodString>;
@@ -48,10 +48,10 @@ export declare const agentGrantSchema: z.ZodObject<{
             agentId: z.ZodString;
             sessionId: z.ZodString;
         }, z.core.$strict>>;
-    }, z.core.$strict>;
+    }, z.core.$strict>>;
     meta: z.ZodOptional<z.ZodJSONSchema>;
     maxDepth: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** A trusted host's bounded, addressed authority for fleet operations. */
 export type AgentGrant = z.infer<typeof agentGrantSchema>;
 /** A committed directory transition, returned in the host's transaction. */
@@ -74,17 +74,17 @@ export declare const agentIds: Readonly<{
 /** An ordinary Agent directory identity. */
 export type AgentId = CairnId<"agent", "agent">;
 /** Stable replay input; configuration is an opaque host creation choice. */
-export declare const agentCreationSchema: z.ZodObject<{
+export declare const agentCreationSchema: z.ZodLazy<z.ZodObject<{
     name: z.ZodString;
     requestId: z.ZodString;
     configuration: z.ZodString;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** One idempotent directory reservation. */
 export type AgentCreation = z.infer<typeof agentCreationSchema>;
 /** Owner-only rename input: an Agent's new display name. */
-export declare const agentRenameSchema: z.ZodObject<{
+export declare const agentRenameSchema: z.ZodLazy<z.ZodObject<{
     name: z.ZodString;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** Input to {@link createAgentDirectory}'s `rename`. */
 export type AgentRename = z.infer<typeof agentRenameSchema>;
 /** One durable Agent directory record. */
@@ -154,12 +154,12 @@ export declare function createAgentDirectory(sql: WatchdogSqliteOwner["sql"]): {
     erasureRosterComplete: () => boolean;
 };
 /** Replay identity and work, with the parent supplied exclusively by the grant. */
-export declare const agentDelegationTaskSchema: z.ZodObject<{
+export declare const agentDelegationTaskSchema: z.ZodLazy<z.ZodObject<{
     requestId: z.ZodString;
     agentId: z.ZodString;
     sessionId: z.ZodOptional<z.ZodString>;
     text: z.ZodString;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** A caller reuses this task unchanged while polling Pending. */
 export type AgentDelegationTask = z.infer<typeof agentDelegationTaskSchema>;
 /** Exact host facts encoded over internal transports, without transcript content. */
@@ -231,17 +231,6 @@ 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.
@@ -250,11 +239,6 @@ export type FleetRecipients = Readonly<{
 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

@@ -18,7 +18,7 @@ export const agentActionSchema = z.enum([
     "delegate",
 ]);
 /** Attribution supplied by the admitting host, without Team semantics. */
-export const agentProvenanceSchema = z.strictObject({
+export const agentProvenanceSchema = z.lazy(() => z.strictObject({
     actor: identity,
     workflowRunId: identity.optional(),
     /** Host fingerprint of the enclosing model program, frozen with replay input. */
@@ -29,9 +29,9 @@ export const agentProvenanceSchema = z.strictObject({
     session: z
         .strictObject({ agentId: identity, sessionId: identity })
         .optional(),
-});
+}));
 /** Fleet authority is supplied, never looked up in host policy. */
-export const agentGrantSchema = z.strictObject({
+export const agentGrantSchema = z.lazy(() => z.strictObject({
     agents: z.union([z.literal("all"), z.array(identity)]),
     actions: z.array(agentActionSchema).max(5),
     expiresAt: z.number().int().nonnegative(),
@@ -39,7 +39,7 @@ export const agentGrantSchema = z.strictObject({
     meta: z.json().optional(),
     /** Delegation abuse bound; inherited paths may only narrow it. */
     maxDepth: z.number().int().min(1).max(8).optional(),
-});
+}));
 /** Refusal of supplied authority; no host policy lookup is performed. */
 export class AgentGrantError extends Error {
     reason;
@@ -67,30 +67,30 @@ export const agentIds = defineIdFamily({
     version: 1,
     kinds: { agent: { prefix: "agent" } },
 });
-const agentRowSchema = z.strictObject({
+const agentRowSchema = z.lazy(() => z.strictObject({
     agent_id: z.string(),
     name: z.string(),
     actor_user_id: z.string(),
     created_at: z.number().int().nonnegative(),
     updated_at: z.number().int().nonnegative(),
-});
-const receiptRowSchema = z.strictObject({
+}));
+const receiptRowSchema = z.lazy(() => z.strictObject({
     request_id: z.string(),
     actor_user_id: z.string(),
     name: z.string(),
     agent_id: z.string(),
     computer_mode: z.string().min(1).max(4096),
-});
+}));
 /** Stable replay input; configuration is an opaque host creation choice. */
-export const agentCreationSchema = z.strictObject({
+export const agentCreationSchema = z.lazy(() => z.strictObject({
     name: z.string().min(1).max(256),
     requestId: z.string().min(1).max(256),
     configuration: z.string().min(1).max(4096),
-});
+}));
 /** Owner-only rename input: an Agent's new display name. */
-export const agentRenameSchema = z.strictObject({
+export const agentRenameSchema = z.lazy(() => z.strictObject({
     name: z.string().min(1).max(256),
-});
+}));
 /** Directory input, replay or storage refusal. */
 export class DirectoryError extends Error {
     status;
@@ -247,7 +247,7 @@ export function createAgentDirectory(sql) {
     };
 }
 /** Replay identity and work, with the parent supplied exclusively by the grant. */
-export const agentDelegationTaskSchema = z.strictObject({
+export const agentDelegationTaskSchema = z.lazy(() => z.strictObject({
     requestId: identity,
     agentId: identity,
     sessionId: identity.optional(),
@@ -255,7 +255,7 @@ export const agentDelegationTaskSchema = z.strictObject({
         .string()
         .min(1)
         .max(256 * 1024),
-});
+}));
 /** Exact host facts encoded over internal transports, without transcript content. */
 export const commandSettlementSchema = Schema.Struct({
     terminal: SessionTerminalSchema,
@@ -318,18 +318,12 @@ export function delegationReplyMeta(delegation, replierName) {
 const delegationMetadata = z.object({
     delegation: FungiMessageMetaSchema.shape.delegation,
 });
-const delegationRowSchema = z.strictObject({
+const delegationRowSchema = z.lazy(() => z.strictObject({
     input: z.string(),
     mail: z.string(),
     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.
@@ -470,28 +464,9 @@ 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/woodstock/fleet-store.d.ts

@@ -27,10 +27,6 @@ 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,22 +70,15 @@ 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, invoker?) => Promise<AgentControlAgent>;
+  create?: (input, signal) => Promise<AgentControlAgent>;
   setModel?: (input, signal) => Promise<void>;
   models?: (signal) => Promise<readonly AgentControlModel[]>;
   checkModel?: (input, signal) => Promise<void>;

package/docs/api/fleet.md

@@ -303,33 +303,6 @@ 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
@@ -702,7 +675,6 @@ 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.1.0",
+  "version": "0.2.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.2",
+    "@fungi.computer/knapsack": "0.1.0",
     "@fungi.computer/mule": "0.0.2",
-    "@fungi.computer/mycelium": "0.0.2",
+    "@fungi.computer/mycelium": "0.1.0",
     "@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.1.0"
+    "@fungi.computer/gills": "0.1.0",
+    "@fungi.computer/agar": "0.2.0"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "5.20260828.1",