@fungi.computer/shiitake-extensions 0.4.0 → 0.6.0

package/dist/loop/schema.js

@@ -0,0 +1,49 @@
+import * as Schema from "effect/Schema";
+import { Prompt, SessionId } from "../internal/schedule-fields.js";
+/** A named cron cadence evaluated in one IANA time zone. */
+export const LoopCron = Schema.Struct({
+    /** Cron expression for the fixed cadence. */
+    expression: Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.isMaxLength(256))),
+    /** IANA time zone in which the expression is evaluated. */
+    timeZone: Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.isMaxLength(128))),
+});
+/** One Session's loop as every client sees it. */
+export const Loop = Schema.Struct({
+    /** Identity of the loop whose occurrences are being tracked. */
+    loopId: Schema.String,
+    /** Whether a person or the model started this loop. */
+    origin: Schema.Literals(["human", "model"]),
+    /** Configured expiry timestamp, or null when absent. */
+    expiresAt: Schema.NullOr(Schema.Int),
+    /** Original instruction repeated for every occurrence. */
+    prompt: Prompt,
+    /** Whether the model or a fixed cron cadence schedules occurrences. */
+    mode: Schema.Literals(["self_paced", "fixed_interval"]),
+    /** Cadence of a fixed-interval loop; null when the model paces it. */
+    cron: Schema.NullOr(LoopCron),
+    /** Current loop lifecycle state. */
+    state: Schema.Literals([
+        "active",
+        "paused",
+        "finished",
+        "failed",
+        "cancelled",
+    ]),
+    /** Latest accepted command associated with this loop. */
+    commandId: Schema.String,
+    /** The model's stated reason for the next self-paced occurrence. */
+    reason: Schema.NullOr(Schema.String),
+    /** When the next occurrence is due, if one is scheduled. */
+    nextDueAt: Schema.NullOr(Schema.Int),
+    /** Visible explanation when loop work failed. */
+    lastError: Schema.NullOr(Schema.String),
+    /** Consecutive failed work outcomes; successful work resets this to zero. */
+    consecutiveFailures: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0))),
+});
+/** Native bounded Loop page grammar, also used by shared continuations. */
+export const LoopListInput = Schema.Struct({
+    /** Exclusive Session cursor. */
+    after: Schema.optionalKey(SessionId),
+    /** Maximum number of Loop rows to read. */
+    limit: Schema.optionalKey(Schema.Int.pipe(Schema.check(Schema.isBetween({ minimum: 1, maximum: 64 })))),
+});

package/dist/roster/conversation-agents.d.ts

@@ -6,14 +6,24 @@ import type { SubagentSource } from "../subagents/host.js";
 /** Host-pack creation admission; attachments/model selection retain their own owners. */
 export declare function assertOrdinaryAgentCreation(input: Parameters<NonNullable<AgentControlDirectory["create"]>>[0]): void;
 /** The directory a conversation sends through; opening a recipient only needs its Sessions' extension doors. */
-type SendingDirectory = Omit<AgentControlDirectory, "open"> & Readonly<{
+export type SendingDirectory = Omit<AgentControlDirectory, "open"> & Readonly<{
+    /** Open the recipient's Session extension door for goal adoption. */
     open: (agentId: string, signal: AbortSignal) => Promise<Readonly<{
+        /** Recipient Agent with a Session extension door. */
         agent: Readonly<{
+            /** Address a recipient Session without loading its conversation. */
             session: (sessionId: string) => Pick<ShiitakeSession, "extension">;
         }>;
+        /** Release the acquired recipient without stopping its work. */
         release: () => Promise<void>;
     }>>;
 }>;
+/** Adopt the first accepted turn once, even when the sender was offline at delivery. */
+export declare function adoptDelegatedGoal(session: Pick<ShiitakeSession, "extension">, input: Readonly<{
+    text: string;
+    goal: string | false | undefined;
+    commandId: string;
+}>): Promise<void>;
 /**
  * This host's own record of the Agents each conversation created or sent
  * accepted work to, written as its Agent-control directory accepts them
@@ -35,4 +45,3 @@ export declare function oysterAgentExtensions(source: SubagentSource): Readonly<
     roster: readonly import("@fungi.computer/shiitake").RosteredExtensionV0[];
     grants: readonly import("@fungi.computer/shiitake").ExtensionGrantV0[];
 }>;
-export {};

package/dist/roster/conversation-agents.js

@@ -37,6 +37,18 @@ function laneObjective(text, goal) {
         .map((line) => line.trim())
         .find((line) => line !== "") ?? text.trim()).slice(0, 4_000);
 }
+/** Adopt the first accepted turn once, even when the sender was offline at delivery. */
+export async function adoptDelegatedGoal(session, input) {
+    if (input.goal === false)
+        return;
+    await bindSessionExtension(session, goalContract).call("set", {
+        objective: laneObjective(input.text, input.goal),
+        expectedRevision: null,
+        requestId: `lane-goal:${input.commandId}`,
+        // The delegated prompt is already admitted; never enqueue it twice.
+        adoptCommandId: input.commandId,
+    });
+}
 /**
  * This host's own record of the Agents each conversation created or sent
  * accepted work to, written as its Agent-control directory accepts them
@@ -99,12 +111,10 @@ export function createConversationAgents(storage) {
                             sessionId !== undefined) {
                             const opened = await directory.open(task.agentId, signal);
                             try {
-                                await bindSessionExtension(opened.agent.session(sessionId), goalContract).call("set", {
-                                    objective: laneObjective(task.text, task.goal),
-                                    expectedRevision: null,
-                                    requestId: `lane-goal:${accepted.commandId}`,
-                                    // The send is the lane's first turn; never repeat it.
-                                    adoptCommandId: accepted.commandId,
+                                await adoptDelegatedGoal(opened.agent.session(sessionId), {
+                                    text: task.text,
+                                    goal: task.goal,
+                                    commandId: accepted.commandId,
                                 });
                             }
                             finally {

package/dist/schedules/client.d.ts

@@ -0,0 +1,16 @@
+import type { ShiitakeAgent } from "@fungi.computer/shiitake";
+import type * as z from "zod";
+import { agentScheduleListInputSchema, type AgentScheduleRow, type AgentSchedulePage, type AgentScheduleTarget, type AgentScheduleControlReceipt } from "../schedules.js";
+/**
+ * Read one already-admitted Agent, without scanning Sessions or draining pages.
+ * The caller owns Agent, home and resource authorization and the owner's lifetime.
+ */
+export declare function readAgentSchedulePage(agentId: string, owner: Pick<ShiitakeAgent, "extensions">, input?: z.input<typeof agentScheduleListInputSchema>): Promise<AgentSchedulePage>;
+/**
+ * Explicit content-returning control for callers admitted to both read and manage.
+ * In particular, private Local retains its native-row reply. The supplied owner
+ * must already be admitted for target.agentId; this helper grants no authority.
+ */
+export declare function controlAgentScheduleWithContent(owner: Pick<ShiitakeAgent, "extensions">, input: AgentScheduleTarget, action: "pause" | "resume" | "delete"): Promise<AgentScheduleRow>;
+/** Control an already-admitted owner; manage-only callers receive no read content. */
+export declare function controlAgentSchedule(owner: Pick<ShiitakeAgent, "extensions">, target: AgentScheduleTarget, action: "pause" | "resume" | "delete"): Promise<AgentScheduleControlReceipt>;

package/dist/schedules/client.js

@@ -0,0 +1,81 @@
+import { bindAgentExtension } from "@fungi.computer/shiitake/client";
+import { almanacContract } from "../almanac/contract.js";
+import { loopContract } from "../loop/contract.js";
+import { agentScheduleListInputSchema, agentScheduleTargetSchema, } from "../schedules.js";
+/**
+ * Read one already-admitted Agent, without scanning Sessions or draining pages.
+ * The caller owns Agent, home and resource authorization and the owner's lifetime.
+ */
+export async function readAgentSchedulePage(agentId, owner, input = {}) {
+    const { after, limit } = agentScheduleListInputSchema.parse(input);
+    if (after !== undefined && after.agentId !== agentId)
+        throw new Error("Schedule continuation belongs to another Agent");
+    const items = [];
+    if (after?.kind !== "loop") {
+        const nativeInput = after?.after === undefined ? { limit } : { limit, after: after.after };
+        const rows = await bindAgentExtension(owner, almanacContract).call("list", nativeInput);
+        for (const schedule of rows)
+            items.push({ agentId, kind: "almanac", schedule });
+        const last = rows.at(-1);
+        if (items.length === limit && last !== undefined)
+            return {
+                items,
+                next: { agentId, kind: "almanac", after: last.id },
+            };
+    }
+    const remaining = limit - items.length;
+    const cursor = after?.kind === "loop" ? after.after : undefined;
+    const nativeInput = cursor === undefined
+        ? { limit: remaining }
+        : { limit: remaining, after: cursor };
+    const rows = await bindAgentExtension(owner, loopContract).call("list", nativeInput);
+    for (const schedule of rows)
+        items.push({ agentId, kind: "loop", schedule });
+    const last = rows.at(-1);
+    return {
+        items,
+        next: items.length === limit && last !== undefined
+            ? { agentId, kind: "loop", after: last.sessionId }
+            : null,
+    };
+}
+/**
+ * Explicit content-returning control for callers admitted to both read and manage.
+ * In particular, private Local retains its native-row reply. The supplied owner
+ * must already be admitted for target.agentId; this helper grants no authority.
+ */
+export async function controlAgentScheduleWithContent(owner, input, action) {
+    const target = agentScheduleTargetSchema.parse(input);
+    if (target.kind === "almanac") {
+        const schedule = await bindAgentExtension(owner, almanacContract).call(action === "delete" ? "cancel" : action, { scheduleId: target.scheduleId });
+        return { agentId: target.agentId, kind: "almanac", schedule };
+    }
+    const loop = await bindAgentExtension(owner, loopContract).call(action === "pause"
+        ? "pauseLoop"
+        : action === "resume"
+            ? "resumeLoop"
+            : "stopLoop", { sessionId: target.sessionId, loopId: target.loopId });
+    return {
+        agentId: target.agentId,
+        kind: "loop",
+        schedule: { ...loop, sessionId: target.sessionId },
+    };
+}
+/** Control an already-admitted owner; manage-only callers receive no read content. */
+export async function controlAgentSchedule(owner, target, action) {
+    const row = await controlAgentScheduleWithContent(owner, target, action);
+    return row.kind === "almanac"
+        ? {
+            agentId: row.agentId,
+            kind: "almanac",
+            scheduleId: row.schedule.id,
+            state: row.schedule.state,
+        }
+        : {
+            agentId: row.agentId,
+            kind: "loop",
+            sessionId: row.schedule.sessionId,
+            loopId: row.schedule.loopId,
+            state: row.schedule.state,
+        };
+}

package/dist/schedules.d.ts

@@ -0,0 +1,164 @@
+import * as Schema from "effect/Schema";
+import * as z from "zod";
+/** Exclusive native key within one Agent's Almanac-then-Loop traversal. */
+export declare const agentScheduleCursorSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    kind: z.ZodUnion<readonly [z.ZodLiteral<"almanac">, z.ZodLiteral<"loop">]>;
+    after: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** One bounded read; a full native page conservatively carries continuation. */
+export declare const agentScheduleListInputSchema: z.ZodObject<{
+    after: z.ZodOptional<z.ZodObject<{
+        agentId: z.ZodString;
+        kind: z.ZodUnion<readonly [z.ZodLiteral<"almanac">, z.ZodLiteral<"loop">]>;
+        after: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+/** Content-bearing read projection, decoded by the retained native contracts. */
+export declare const agentScheduleRowSchema: Schema.Union<readonly [Schema.Struct<{
+    /** Agent that owns this Almanac schedule. */
+    readonly agentId: Schema.String;
+    /** Identifies the native Almanac schedule representation. */
+    readonly kind: Schema.Literal<"almanac">;
+    /** Retained Almanac row, including its instruction and lifecycle state. */
+    readonly schedule: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly sessionId: Schema.String;
+        readonly prompt: Schema.String;
+        readonly cron: Schema.NullOr<Schema.Struct<{
+            readonly expression: Schema.String;
+            readonly timeZone: Schema.String;
+        }>>;
+        readonly nextDueAt: Schema.Int;
+        readonly state: Schema.Literals<readonly ["active", "paused", "cancelled", "finished"]>;
+        readonly lastCommandId: Schema.NullOr<Schema.String>;
+        readonly lastError: Schema.NullOr<Schema.String>;
+        readonly attempt: Schema.Int;
+    }>;
+}>, Schema.Struct<{
+    /** Agent that owns this Session's Loop. */
+    readonly agentId: Schema.String;
+    /** Identifies the native Loop representation. */
+    readonly kind: Schema.Literal<"loop">;
+    /** Retained Loop row with the Session identity used to address its owner. */
+    readonly schedule: Schema.Struct<{
+        /** Session containing this exact Loop. */
+        readonly sessionId: Schema.String;
+        readonly loopId: Schema.String;
+        readonly origin: Schema.Literals<readonly ["human", "model"]>;
+        readonly expiresAt: Schema.NullOr<Schema.Int>;
+        readonly prompt: Schema.String;
+        readonly mode: Schema.Literals<readonly ["self_paced", "fixed_interval"]>;
+        readonly cron: Schema.NullOr<Schema.Struct<{
+            readonly expression: Schema.String;
+            readonly timeZone: Schema.String;
+        }>>;
+        readonly state: Schema.Literals<readonly ["active", "paused", "finished", "failed", "cancelled"]>;
+        readonly commandId: Schema.String;
+        readonly reason: Schema.NullOr<Schema.String>;
+        readonly nextDueAt: Schema.NullOr<Schema.Int>;
+        readonly lastError: Schema.NullOr<Schema.String>;
+        readonly consecutiveFailures: Schema.Int;
+    }>;
+}>]>;
+/** One Agent's retained schedule, including its native content. */
+export type AgentScheduleRow = typeof agentScheduleRowSchema.Type;
+/** Exact listed identity; a Loop target never selects its later replacement. */
+export declare const agentScheduleTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"almanac">;
+    agentId: z.ZodString;
+    scheduleId: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"loop">;
+    agentId: z.ZodString;
+    sessionId: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+    loopId: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}, z.core.$strict>], "kind">;
+/** Identity to admit before acquiring the corresponding Agent owner. */
+export type AgentScheduleTarget = z.output<typeof agentScheduleTargetSchema>;
+/** A bounded content-bearing page; owner failures reject rather than look empty. */
+export declare const agentSchedulePageSchema: Schema.Struct<{
+    /** At most 64 retained rows, ordered Almanac first and then Loop. */
+    readonly items: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        /** Agent that owns this Almanac schedule. */
+        readonly agentId: Schema.String;
+        /** Identifies the native Almanac schedule representation. */
+        readonly kind: Schema.Literal<"almanac">;
+        /** Retained Almanac row, including its instruction and lifecycle state. */
+        readonly schedule: Schema.Struct<{
+            readonly id: Schema.String;
+            readonly sessionId: Schema.String;
+            readonly prompt: Schema.String;
+            readonly cron: Schema.NullOr<Schema.Struct<{
+                readonly expression: Schema.String;
+                readonly timeZone: Schema.String;
+            }>>;
+            readonly nextDueAt: Schema.Int;
+            readonly state: Schema.Literals<readonly ["active", "paused", "cancelled", "finished"]>;
+            readonly lastCommandId: Schema.NullOr<Schema.String>;
+            readonly lastError: Schema.NullOr<Schema.String>;
+            readonly attempt: Schema.Int;
+        }>;
+    }>, Schema.Struct<{
+        /** Agent that owns this Session's Loop. */
+        readonly agentId: Schema.String;
+        /** Identifies the native Loop representation. */
+        readonly kind: Schema.Literal<"loop">;
+        /** Retained Loop row with the Session identity used to address its owner. */
+        readonly schedule: Schema.Struct<{
+            /** Session containing this exact Loop. */
+            readonly sessionId: Schema.String;
+            readonly loopId: Schema.String;
+            readonly origin: Schema.Literals<readonly ["human", "model"]>;
+            readonly expiresAt: Schema.NullOr<Schema.Int>;
+            readonly prompt: Schema.String;
+            readonly mode: Schema.Literals<readonly ["self_paced", "fixed_interval"]>;
+            readonly cron: Schema.NullOr<Schema.Struct<{
+                readonly expression: Schema.String;
+                readonly timeZone: Schema.String;
+            }>>;
+            readonly state: Schema.Literals<readonly ["active", "paused", "finished", "failed", "cancelled"]>;
+            readonly commandId: Schema.String;
+            readonly reason: Schema.NullOr<Schema.String>;
+            readonly nextDueAt: Schema.NullOr<Schema.Int>;
+            readonly lastError: Schema.NullOr<Schema.String>;
+            readonly consecutiveFailures: Schema.Int;
+        }>;
+    }>]>>;
+    /** Exclusive continuation on a full page, or null when both kinds are exhausted. */
+    readonly next: Schema.NullOr<Schema.Struct<{
+        /** Agent whose traversal the next request must continue. */
+        readonly agentId: Schema.String;
+        /** Native owner to continue within that Agent. */
+        readonly kind: Schema.Literals<readonly ["almanac", "loop"]>;
+        /** Exclusive schedule ID or Session ID; absent starts the native kind. */
+        readonly after: Schema.optionalKey<Schema.String>;
+    }>>;
+}>;
+/** One Agent's page, with no directory fan-out or availability policy. */
+export type AgentSchedulePage = typeof agentSchedulePageSchema.Type;
+/** Manage-only result: exact target and native state, never prompt or history. */
+export declare const agentScheduleControlReceiptSchema: Schema.Union<readonly [Schema.Struct<{
+    /** Agent whose Almanac owner completed the transition. */
+    readonly agentId: Schema.String;
+    /** Identifies the controlled native Almanac schedule. */
+    readonly kind: Schema.Literal<"almanac">;
+    /** Identity of the schedule that was paused or cancelled. */
+    readonly scheduleId: Schema.String;
+    /** Native lifecycle state returned after the transition. */
+    readonly state: Schema.Literals<readonly ["active", "paused", "cancelled", "finished"]>;
+}>, Schema.Struct<{
+    /** Agent whose Loop owner completed the transition. */
+    readonly agentId: Schema.String;
+    /** Identifies the controlled native Loop. */
+    readonly kind: Schema.Literal<"loop">;
+    /** Session containing the controlled Loop. */
+    readonly sessionId: Schema.String;
+    /** Exact Loop identity checked by the native transition. */
+    readonly loopId: Schema.String;
+    /** Native lifecycle state returned after the transition. */
+    readonly state: Schema.Literals<readonly ["active", "paused", "finished", "failed", "cancelled"]>;
+}>]>;
+/** Content-free acknowledgement of the native owner's completed transition. */
+export type AgentScheduleControlReceipt = typeof agentScheduleControlReceiptSchema.Type;

package/dist/schedules.js

@@ -0,0 +1,107 @@
+import * as Schema from "effect/Schema";
+import * as z from "zod";
+import { Schedule, ScheduleListInput } from "./almanac/schema.js";
+import { Loop, LoopListInput } from "./loop/schema.js";
+import { SessionId as LoopSessionId } from "./internal/schedule-fields.js";
+const identity = z.string().min(1).max(256);
+/** Exclusive native key within one Agent's Almanac-then-Loop traversal. */
+export const agentScheduleCursorSchema = z
+    .strictObject({
+    /** Agent whose retained schedules this continuation traverses. */
+    agentId: identity,
+    /** Native owner to continue; Almanac precedes Loop in a fresh traversal. */
+    kind: z.union([z.literal("almanac"), z.literal("loop")]),
+    /** Exclusive Almanac schedule ID or Loop Session ID; absent starts the kind. */
+    after: identity.optional(),
+})
+    .refine(({ kind, after }) => Schema.is(kind === "almanac" ? ScheduleListInput : LoopListInput)(after === undefined ? {} : { after }), { message: "Invalid schedule continuation key" });
+/** One bounded read; a full native page conservatively carries continuation. */
+export const agentScheduleListInputSchema = z.strictObject({
+    /** Native continuation from the previous page of this Agent's schedules. */
+    after: agentScheduleCursorSchema.optional(),
+    /** Shared row budget across both native kinds; defaults to and cannot exceed 64. */
+    limit: z.number().int().min(1).max(64).default(64),
+});
+/** Content-bearing read projection, decoded by the retained native contracts. */
+export const agentScheduleRowSchema = Schema.Union([
+    Schema.Struct({
+        /** Agent that owns this Almanac schedule. */
+        agentId: Schema.String,
+        /** Identifies the native Almanac schedule representation. */
+        kind: Schema.Literal("almanac"),
+        /** Retained Almanac row, including its instruction and lifecycle state. */
+        schedule: Schedule,
+    }),
+    Schema.Struct({
+        /** Agent that owns this Session's Loop. */
+        agentId: Schema.String,
+        /** Identifies the native Loop representation. */
+        kind: Schema.Literal("loop"),
+        /** Retained Loop row with the Session identity used to address its owner. */
+        schedule: Schema.Struct({
+            ...Loop.fields,
+            /** Session containing this exact Loop. */
+            sessionId: LoopSessionId,
+        }),
+    }),
+]);
+/** Exact listed identity; a Loop target never selects its later replacement. */
+export const agentScheduleTargetSchema = z.discriminatedUnion("kind", [
+    z.strictObject({
+        /** Selects the native Almanac control. */
+        kind: z.literal("almanac"),
+        /** Agent whose owner the caller must admit before controlling this target. */
+        agentId: identity,
+        /** Exact native Almanac schedule to pause or cancel. */
+        scheduleId: identity.refine(Schema.is(Schedule.fields.id)),
+    }),
+    z.strictObject({
+        /** Selects an identified native Loop control. */
+        kind: z.literal("loop"),
+        /** Agent whose owner the caller must admit before controlling this target. */
+        agentId: identity,
+        /** Session containing the listed Loop. */
+        sessionId: identity.refine(Schema.is(LoopSessionId)),
+        /** Exact listed Loop identity; a replacement must not be controlled instead. */
+        loopId: identity.refine(Schema.is(Loop.fields.loopId)),
+    }),
+]);
+/** A bounded content-bearing page; owner failures reject rather than look empty. */
+export const agentSchedulePageSchema = Schema.Struct({
+    /** At most 64 retained rows, ordered Almanac first and then Loop. */
+    items: Schema.Array(agentScheduleRowSchema).check(Schema.isMaxLength(64)),
+    /** Exclusive continuation on a full page, or null when both kinds are exhausted. */
+    next: Schema.NullOr(Schema.Struct({
+        /** Agent whose traversal the next request must continue. */
+        agentId: Schema.String,
+        /** Native owner to continue within that Agent. */
+        kind: Schema.Literals(["almanac", "loop"]),
+        /** Exclusive schedule ID or Session ID; absent starts the native kind. */
+        after: Schema.optionalKey(Schema.String),
+    })),
+});
+/** Manage-only result: exact target and native state, never prompt or history. */
+export const agentScheduleControlReceiptSchema = Schema.Union([
+    Schema.Struct({
+        /** Agent whose Almanac owner completed the transition. */
+        agentId: Schema.String,
+        /** Identifies the controlled native Almanac schedule. */
+        kind: Schema.Literal("almanac"),
+        /** Identity of the schedule that was paused or cancelled. */
+        scheduleId: Schedule.fields.id,
+        /** Native lifecycle state returned after the transition. */
+        state: Schedule.fields.state,
+    }),
+    Schema.Struct({
+        /** Agent whose Loop owner completed the transition. */
+        agentId: Schema.String,
+        /** Identifies the controlled native Loop. */
+        kind: Schema.Literal("loop"),
+        /** Session containing the controlled Loop. */
+        sessionId: LoopSessionId,
+        /** Exact Loop identity checked by the native transition. */
+        loopId: Loop.fields.loopId,
+        /** Native lifecycle state returned after the transition. */
+        state: Loop.fields.state,
+    }),
+]);

package/docs/api/README.md

@@ -28,6 +28,8 @@
 | [question/host](question/host.md)                           | -           |
 | [roster](roster.md)                                         | -           |
 | [roster/conversation-agents](roster/conversation-agents.md) | -           |
+| [schedules](schedules.md)                                   | -           |
+| [schedules/client](schedules/client.md)                     | -           |
 | [skills/host](skills/host.md)                               | -           |
 | [skills/source](skills/source.md)                           | -           |
 | [subagents/client](subagents/client.md)                     | -           |