@fungi.computer/shiitake-extensions 0.0.1 → 0.1.0

package/dist/home/routing.js

@@ -36,36 +36,15 @@ export function homeFilesRouting(connections, home) {
         },
         list: async (input, context) => {
             const { port, path, locate } = resolve(input.path);
-            const result = await port.list({ ...input, path }, context);
-            return {
-                ...result,
-                path: input.path,
-                entries: result.entries.map((entry) => ({
-                    ...entry,
-                    path: locate(entry.path),
-                })),
-            };
+            return locateSearch(await port.list({ ...input, path }, context), input.path, locate);
         },
         glob: async (input, context) => {
             const { port, path, locate } = resolve(input.path);
-            const result = await port.glob({ ...input, path }, context);
-            return {
-                ...result,
-                path: input.path,
-                matches: result.matches.map(locate),
-            };
+            return locateSearch(await port.glob({ ...input, path }, context), input.path, locate);
         },
         grep: async (input, context) => {
             const { port, path, locate } = resolve(input.path);
-            const result = await port.grep({ ...input, path }, context);
-            return {
-                ...result,
-                path: input.path,
-                matches: result.matches.map((match) => ({
-                    ...match,
-                    path: locate(match.path),
-                })),
-            };
+            return locateSearch(await port.grep({ ...input, path }, context), input.path, locate);
         },
         replace: async (input, context) => {
             const { port, path } = resolve(input.path);
@@ -78,3 +57,13 @@ export function homeFilesRouting(connections, home) {
     const patch = home.patch?.bind(home);
     return patch === undefined ? routing : { ...routing, patch };
 }
+function locateSearch(result, path, locate) {
+    return {
+        ...result,
+        path,
+        results: result.results.map((found) => ({
+            ...found,
+            path: locate(found.path),
+        })),
+    };
+}

package/dist/internal/history.d.ts

@@ -1,25 +1,41 @@
 import * as Schema from "effect/Schema";
 /** Producer state: committed event identity survives reconnection and trimming. */
 export declare function historySchema<E, EI>(event: Schema.Codec<E, EI>): Schema.Struct<{
+    /** Sequence to assign to the next committed event. */
     readonly nextSequence: Schema.Int;
+    /** Number of older events removed by retention. */
     readonly omitted: Schema.Int;
+    /** Retained committed events in sequence order. */
     readonly events: Schema.$Array<Schema.Struct<{
+        /** Stable event identity within this producer's history. */
         readonly id: Schema.String;
+        /** Producer-assigned event order. */
         readonly sequence: Schema.Int;
+        /** Event timestamp supplied by the owner. */
         readonly at: Schema.Int;
+        /** Associated accepted command, or null when none applies. */
         readonly commandId: Schema.NullOr<Schema.String>;
+        /** Extension-specific event payload. */
         readonly event: Schema.Codec<E, EI, never, never>;
     }>>;
 }>;
 /** The extension's own persisted history, not a core cursor. */
 export type History<E> = Readonly<{
+    /** Sequence to assign to the next committed event. */
     nextSequence: number;
+    /** Number of older events removed by retention. */
     omitted: number;
+    /** Retained committed events in sequence order. */
     events: readonly Readonly<{
+        /** Stable event identity within this producer's history. */
         id: string;
+        /** Producer-assigned event order. */
         sequence: number;
+        /** Event timestamp supplied by the owner. */
         at: number;
+        /** Associated accepted command, or null when none applies. */
         commandId: string | null;
+        /** Extension-specific event payload. */
         event: E;
     }>[];
 }>;

package/dist/internal/history.js

@@ -2,13 +2,21 @@ import * as Schema from "effect/Schema";
 /** Producer state: committed event identity survives reconnection and trimming. */
 export function historySchema(event) {
     return Schema.Struct({
+        /** Sequence to assign to the next committed event. */
         nextSequence: Schema.Int.check(Schema.isGreaterThan(0)),
+        /** Number of older events removed by retention. */
         omitted: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+        /** Retained committed events in sequence order. */
         events: Schema.Array(Schema.Struct({
+            /** Stable event identity within this producer's history. */
             id: Schema.String,
+            /** Producer-assigned event order. */
             sequence: Schema.Int,
+            /** Event timestamp supplied by the owner. */
             at: Schema.Int,
+            /** Associated accepted command, or null when none applies. */
             commandId: Schema.NullOr(Schema.String),
+            /** Extension-specific event payload. */
             event,
         })),
     });

package/dist/loop/client.d.ts

@@ -3,7 +3,7 @@ import { type ClientContributionV1 } from "@fungi.computer/shiitake/client-entry
 declare const _default: Readonly<{
     protocol: "shiitake.client/v1";
     id: import("@fungi.computer/shiitake/extensions").ExtensionId;
-    correlatedPrompts?: "note";
+    promptPresentation?: "footer";
     attach?: (context: import("@fungi.computer/shiitake/client-entry").ClientExtensionContextV1) => import("effect/Effect").Effect<void, Error, import("effect/Scope").Scope>;
     contribute?: (slot: import("@fungi.computer/shiitake").ExtensionSlotV0 | undefined) => ClientContributionV1;
 }>;

package/dist/loop/client.js

@@ -1,5 +1,10 @@
 import { defineClientEntry, } from "@fungi.computer/shiitake/client-entry";
 import { loopContract } from "./contract.js";
+/** One footer line: the full prompt stays in the row's detail. */
+const summary = (text) => {
+    const line = text.replace(/\s+/gu, " ").trim();
+    return line.length <= 60 ? line : `${line.slice(0, 59)}…`;
+};
 const tone = (loop) => loop.state === "failed"
     ? "error"
     : loop.state === "active"
@@ -17,6 +22,7 @@ const due = (at) => new Intl.DateTimeFormat(undefined, {
 }).format(at);
 /** Loop supplies its own absolute due copy and advertised stop intent. */
 export default defineClientEntry(loopContract, {
+    promptPresentation: "footer",
     contribute: (view) => {
         if (view.status !== "running" || view.value === null)
             return {
@@ -25,10 +31,10 @@ export default defineClientEntry(loopContract, {
                 timeline: { cells: [], omitted: 0 },
                 waiting: null,
             };
-        const { loop, history } = view.value;
-        const waiting = loop !== null && loop.state === "active" && loop.nextDueAt !== null;
+        const { loop } = view.value;
+        const waiting = loop.state === "active" && loop.nextDueAt !== null;
         return {
-            chips: loop === null || (loop.state !== "active" && loop.state !== "paused")
+            chips: loop.state !== "active" && loop.state !== "paused"
                 ? []
                 : [
                     {
@@ -41,39 +47,27 @@ export default defineClientEntry(loopContract, {
                         },
                     },
                 ],
-            panel: loop === null
-                ? []
-                : [
-                    {
-                        id: "loop",
-                        title: `Loop · ${loop.state} · ${loop.mode === "self_paced" ? "self-paced" : `${loop.cron?.expression ?? "fixed"} ${loop.cron?.timeZone ?? ""}`}${loop.nextDueAt === null ? "" : ` · Next ${due(loop.nextDueAt)}`}`,
-                        detail: loop.prompt.slice(0, 1024),
-                        tone: tone(loop),
-                    },
-                    ...(loop.lastError === null
-                        ? []
-                        : [
-                            {
-                                id: "error",
-                                title: loop.lastError.slice(0, 4096),
-                                tone: "error",
-                            },
-                        ]),
-                ],
-            timeline: {
-                omitted: history.omitted,
-                cells: history.events.map(({ event, ...cell }) => ({
-                    ...cell,
-                    rows: [
+            panel: [
+                {
+                    id: "loop",
+                    title: `Loop · ${loop.state} · ${loop.mode === "self_paced" ? "self-paced" : `${loop.cron?.expression ?? "fixed"} ${loop.cron?.timeZone ?? ""}`}${loop.nextDueAt === null ? "" : ` · Next ${due(loop.nextDueAt)}`} · ${summary(loop.prompt)}`,
+                    detail: [loop.reason, loop.prompt]
+                        .filter((part) => part !== null)
+                        .join("\n")
+                        .slice(0, 1024),
+                    tone: tone(loop),
+                },
+                ...(loop.lastError === null
+                    ? []
+                    : [
                         {
-                            id: "loop",
-                            title: `Loop ${event.state}`,
-                            detail: (event.lastError ?? event.reason ?? event.prompt).slice(0, 1024),
-                            tone: tone(event),
+                            id: "error",
+                            title: loop.lastError.slice(0, 4096),
+                            tone: "error",
                         },
-                    ],
-                })),
-            },
+                    ]),
+            ],
+            timeline: { cells: [], omitted: 0 },
             waiting: waiting
                 ? {
                     summary: `Waiting until ${due(loop.nextDueAt)}`,

package/dist/loop/contract.d.ts

@@ -1,22 +1,31 @@
 import * as Schema from "effect/Schema";
 /** A named cron cadence evaluated in one IANA time zone. */
 export declare const LoopCron: Schema.Struct<{
+    /** Cron expression for the fixed cadence. */
     readonly expression: Schema.String;
+    /** IANA time zone in which the expression is evaluated. */
     readonly timeZone: Schema.String;
 }>;
 /** One Session's loop as every client sees it. */
 export declare const Loop: Schema.Struct<{
+    /** Identity of the loop whose occurrences are being tracked. */
     readonly loopId: Schema.String;
+    /** Whether a person or the model started this loop. */
     readonly origin: Schema.Literals<readonly ["human", "model"]>;
+    /** Configured expiry timestamp, or null when absent. */
     readonly expiresAt: Schema.NullOr<Schema.Int>;
     /** Original instruction repeated for every occurrence. */
     readonly prompt: Schema.String;
+    /** Whether the model or a fixed cron cadence schedules occurrences. */
     readonly mode: Schema.Literals<readonly ["self_paced", "fixed_interval"]>;
     /** Cadence of a fixed-interval loop; null when the model paces it. */
     readonly cron: Schema.NullOr<Schema.Struct<{
+        /** Cron expression for the fixed cadence. */
         readonly expression: Schema.String;
+        /** IANA time zone in which the expression is evaluated. */
         readonly timeZone: Schema.String;
     }>>;
+    /** Current loop lifecycle state. */
     readonly state: Schema.Literals<readonly ["active", "paused", "finished", "failed", "cancelled"]>;
     /** Latest accepted command associated with this loop. */
     readonly commandId: Schema.String;
@@ -35,26 +44,38 @@ export type Loop = Schema.Schema.Type<typeof Loop>;
  * interval. A bare call opens the controls.
  */
 export declare const LoopCommandInput: Schema.Union<readonly [Schema.Struct<{
+    /** Select the loop-starting control. */
     readonly action: Schema.Literal<"start">;
+    /** Human prompt text, optionally prefixed with an interval. */
     readonly text: Schema.String;
+    /** Idempotency key for this start command. */
     readonly requestId: Schema.String;
 }>, Schema.Struct<{
+    /** Select an existing-loop control or open new-loop entry. */
     readonly action: Schema.Literals<readonly ["status", "pause", "resume", "stop", "new"]>;
 }>, Schema.Struct<{}>]>;
 /** Loop's contract: Session-scope controls and one projection slot. */
 export declare const LoopProjection: Schema.Struct<{
-    readonly loop: Schema.NullOr<Schema.Struct<{
+    /** Loop currently visible to Session clients. */
+    readonly loop: Schema.Struct<{
+        /** Identity of the loop whose occurrences are being tracked. */
         readonly loopId: Schema.String;
+        /** Whether a person or the model started this loop. */
         readonly origin: Schema.Literals<readonly ["human", "model"]>;
+        /** Configured expiry timestamp, or null when absent. */
         readonly expiresAt: Schema.NullOr<Schema.Int>;
         /** Original instruction repeated for every occurrence. */
         readonly prompt: Schema.String;
+        /** Whether the model or a fixed cron cadence schedules occurrences. */
         readonly mode: Schema.Literals<readonly ["self_paced", "fixed_interval"]>;
         /** Cadence of a fixed-interval loop; null when the model paces it. */
         readonly cron: Schema.NullOr<Schema.Struct<{
+            /** Cron expression for the fixed cadence. */
             readonly expression: Schema.String;
+            /** IANA time zone in which the expression is evaluated. */
             readonly timeZone: Schema.String;
         }>>;
+        /** Current loop lifecycle state. */
         readonly state: Schema.Literals<readonly ["active", "paused", "finished", "failed", "cancelled"]>;
         /** Latest accepted command associated with this loop. */
         readonly commandId: Schema.String;
@@ -64,82 +85,66 @@ export declare const LoopProjection: Schema.Struct<{
         readonly nextDueAt: Schema.NullOr<Schema.Int>;
         /** Visible explanation when loop work failed. */
         readonly lastError: Schema.NullOr<Schema.String>;
-    }>>;
-    readonly history: Schema.Struct<{
-        readonly nextSequence: Schema.Int;
-        readonly omitted: Schema.Int;
-        readonly events: Schema.$Array<Schema.Struct<{
-            readonly id: Schema.String;
-            readonly sequence: Schema.Int;
-            readonly at: Schema.Int;
-            readonly commandId: Schema.NullOr<Schema.String>;
-            readonly event: Schema.Codec<{
-                readonly loopId: string;
-                readonly origin: "human" | "model";
-                readonly expiresAt: number | null;
-                readonly prompt: string;
-                readonly mode: "self_paced" | "fixed_interval";
-                readonly cron: {
-                    readonly expression: string;
-                    readonly timeZone: string;
-                } | null;
-                readonly state: "active" | "paused" | "cancelled" | "finished" | "failed";
-                readonly commandId: string;
-                readonly reason: string | null;
-                readonly nextDueAt: number | null;
-                readonly lastError: string | null;
-            }, {
-                readonly loopId: string;
-                readonly origin: "human" | "model";
-                readonly expiresAt: number | null;
-                readonly prompt: string;
-                readonly mode: "self_paced" | "fixed_interval";
-                readonly cron: {
-                    readonly expression: string;
-                    readonly timeZone: string;
-                } | null;
-                readonly state: "active" | "paused" | "cancelled" | "finished" | "failed";
-                readonly commandId: string;
-                readonly reason: string | null;
-                readonly nextDueAt: number | null;
-                readonly lastError: string | null;
-            }, never, never>;
-        }>>;
     }>;
 }>;
+/** Session-owned loop controls and their visible state. */
 export declare const loopContract: {
+    /** Stable extension identity. */
     readonly id: string & import("effect/Brand").Brand<"ExtensionId">;
+    /** Loop operations admitted by the Session owner. */
     readonly commands: {
+        /** Open or answer the human loop controls. */
         readonly loop: {
+            /** The Session owns this loop. */
             readonly scope: "session";
+            /** Decode the selected human action. */
             readonly input: Schema.Union<readonly [Schema.Struct<{
+                /** Select the loop-starting control. */
                 readonly action: Schema.Literal<"start">;
+                /** Human prompt text, optionally prefixed with an interval. */
                 readonly text: Schema.String;
+                /** Idempotency key for this start command. */
                 readonly requestId: Schema.String;
             }>, Schema.Struct<{
+                /** Select an existing-loop control or open new-loop entry. */
                 readonly action: Schema.Literals<readonly ["status", "pause", "resume", "stop", "new"]>;
             }>, Schema.Struct<{}>]>;
+            /** Return the server-owned conversation step. */
             readonly output: Schema.declare<import("@fungi.computer/whistle/catalog").WhistleCatalogStepV1, import("@fungi.computer/whistle/catalog").WhistleCatalogStepV1>;
         };
+        /** Start a loop whose next occurrence is chosen by the model. */
         readonly startSelfPaced: {
+            /** The Session owns this loop. */
             readonly scope: "session";
+            /** Decode the repeated prompt and command identity. */
             readonly input: Schema.Struct<{
+                /** Instruction repeated on every occurrence. */
                 readonly prompt: Schema.String;
+                /** Idempotency key for the start command. */
                 readonly requestId: Schema.String;
             }>;
+            /** Return the loop and admission receipt. */
             readonly output: Schema.Struct<{
+                /** Newly started loop. */
                 readonly loop: Schema.Struct<{
+                    /** Identity of the loop whose occurrences are being tracked. */
                     readonly loopId: Schema.String;
+                    /** Whether a person or the model started this loop. */
                     readonly origin: Schema.Literals<readonly ["human", "model"]>;
+                    /** Configured expiry timestamp, or null when absent. */
                     readonly expiresAt: Schema.NullOr<Schema.Int>;
                     /** Original instruction repeated for every occurrence. */
                     readonly prompt: Schema.String;
+                    /** Whether the model or a fixed cron cadence schedules occurrences. */
                     readonly mode: Schema.Literals<readonly ["self_paced", "fixed_interval"]>;
                     /** Cadence of a fixed-interval loop; null when the model paces it. */
                     readonly cron: Schema.NullOr<Schema.Struct<{
+                        /** Cron expression for the fixed cadence. */
                         readonly expression: Schema.String;
+                        /** IANA time zone in which the expression is evaluated. */
                         readonly timeZone: Schema.String;
                     }>>;
+                    /** Current loop lifecycle state. */
                     readonly state: Schema.Literals<readonly ["active", "paused", "finished", "failed", "cancelled"]>;
                     /** Latest accepted command associated with this loop. */
                     readonly commandId: Schema.String;
@@ -150,33 +155,52 @@ export declare const loopContract: {
                     /** Visible explanation when loop work failed. */
                     readonly lastError: Schema.NullOr<Schema.String>;
                 }>;
+                /** Admission receipt for the start command. */
                 readonly accepted: Schema.Struct<{
+                    /** Successful admission discriminator. */
                     readonly status: Schema.Literal<"accepted">;
+                    /** Identity of the accepted start command. */
                     readonly commandId: Schema.String;
                 }>;
             }>;
         };
+        /** Start a loop with a fixed cron cadence. */
         readonly startFixedInterval: {
+            /** The Session owns this loop. */
             readonly scope: "session";
+            /** Decode the prompt, cadence and command identity. */
             readonly input: Schema.Struct<{
+                /** Cron expression for the fixed cadence. */
                 readonly expression: Schema.String;
+                /** IANA time zone in which the expression is evaluated. */
                 readonly timeZone: Schema.String;
+                /** Instruction repeated on every occurrence. */
                 readonly prompt: Schema.String;
+                /** Idempotency key for the start command. */
                 readonly requestId: Schema.String;
             }>;
+            /** Return the loop and admission receipt. */
             readonly output: Schema.Struct<{
+                /** Newly started loop. */
                 readonly loop: Schema.Struct<{
+                    /** Identity of the loop whose occurrences are being tracked. */
                     readonly loopId: Schema.String;
+                    /** Whether a person or the model started this loop. */
                     readonly origin: Schema.Literals<readonly ["human", "model"]>;
+                    /** Configured expiry timestamp, or null when absent. */
                     readonly expiresAt: Schema.NullOr<Schema.Int>;
                     /** Original instruction repeated for every occurrence. */
                     readonly prompt: Schema.String;
+                    /** Whether the model or a fixed cron cadence schedules occurrences. */
                     readonly mode: Schema.Literals<readonly ["self_paced", "fixed_interval"]>;
                     /** Cadence of a fixed-interval loop; null when the model paces it. */
                     readonly cron: Schema.NullOr<Schema.Struct<{
+                        /** Cron expression for the fixed cadence. */
                         readonly expression: Schema.String;
+                        /** IANA time zone in which the expression is evaluated. */
                         readonly timeZone: Schema.String;
                     }>>;
+                    /** Current loop lifecycle state. */
                     readonly state: Schema.Literals<readonly ["active", "paused", "finished", "failed", "cancelled"]>;
                     /** Latest accepted command associated with this loop. */
                     readonly commandId: Schema.String;
@@ -187,27 +211,41 @@ export declare const loopContract: {
                     /** Visible explanation when loop work failed. */
                     readonly lastError: Schema.NullOr<Schema.String>;
                 }>;
+                /** Admission receipt for the start command. */
                 readonly accepted: Schema.Struct<{
+                    /** Successful admission discriminator. */
                     readonly status: Schema.Literal<"accepted">;
+                    /** Identity of the accepted start command. */
                     readonly commandId: Schema.String;
                 }>;
             }>;
         };
+        /** Suspend the current loop. */
         readonly pause: {
+            /** The Session owns this loop. */
             readonly scope: "session";
+            /** No additional arguments are required. */
             readonly input: Schema.Struct<{}>;
+            /** Return the paused loop. */
             readonly output: Schema.Struct<{
+                /** Identity of the loop whose occurrences are being tracked. */
                 readonly loopId: Schema.String;
+                /** Whether a person or the model started this loop. */
                 readonly origin: Schema.Literals<readonly ["human", "model"]>;
+                /** Configured expiry timestamp, or null when absent. */
                 readonly expiresAt: Schema.NullOr<Schema.Int>;
                 /** Original instruction repeated for every occurrence. */
                 readonly prompt: Schema.String;
+                /** Whether the model or a fixed cron cadence schedules occurrences. */
                 readonly mode: Schema.Literals<readonly ["self_paced", "fixed_interval"]>;
                 /** Cadence of a fixed-interval loop; null when the model paces it. */
                 readonly cron: Schema.NullOr<Schema.Struct<{
+                    /** Cron expression for the fixed cadence. */
                     readonly expression: Schema.String;
+                    /** IANA time zone in which the expression is evaluated. */
                     readonly timeZone: Schema.String;
                 }>>;
+                /** Current loop lifecycle state. */
                 readonly state: Schema.Literals<readonly ["active", "paused", "finished", "failed", "cancelled"]>;
                 /** Latest accepted command associated with this loop. */
                 readonly commandId: Schema.String;
@@ -219,21 +257,32 @@ export declare const loopContract: {
                 readonly lastError: Schema.NullOr<Schema.String>;
             }>;
         };
+        /** Resume the current paused loop. */
         readonly resume: {
+            /** The Session owns this loop. */
             readonly scope: "session";
+            /** No additional arguments are required. */
             readonly input: Schema.Struct<{}>;
+            /** Return the resumed loop. */
             readonly output: Schema.Struct<{
+                /** Identity of the loop whose occurrences are being tracked. */
                 readonly loopId: Schema.String;
+                /** Whether a person or the model started this loop. */
                 readonly origin: Schema.Literals<readonly ["human", "model"]>;
+                /** Configured expiry timestamp, or null when absent. */
                 readonly expiresAt: Schema.NullOr<Schema.Int>;
                 /** Original instruction repeated for every occurrence. */
                 readonly prompt: Schema.String;
+                /** Whether the model or a fixed cron cadence schedules occurrences. */
                 readonly mode: Schema.Literals<readonly ["self_paced", "fixed_interval"]>;
                 /** Cadence of a fixed-interval loop; null when the model paces it. */
                 readonly cron: Schema.NullOr<Schema.Struct<{
+                    /** Cron expression for the fixed cadence. */
                     readonly expression: Schema.String;
+                    /** IANA time zone in which the expression is evaluated. */
                     readonly timeZone: Schema.String;
                 }>>;
+                /** Current loop lifecycle state. */
                 readonly state: Schema.Literals<readonly ["active", "paused", "finished", "failed", "cancelled"]>;
                 /** Latest accepted command associated with this loop. */
                 readonly commandId: Schema.String;
@@ -245,21 +294,32 @@ export declare const loopContract: {
                 readonly lastError: Schema.NullOr<Schema.String>;
             }>;
         };
+        /** Stop future occurrences of the current loop. */
         readonly stop: {
+            /** The Session owns this loop. */
             readonly scope: "session";
+            /** No additional arguments are required. */
             readonly input: Schema.Struct<{}>;
+            /** Return the stopped loop. */
             readonly output: Schema.Struct<{
+                /** Identity of the loop whose occurrences are being tracked. */
                 readonly loopId: Schema.String;
+                /** Whether a person or the model started this loop. */
                 readonly origin: Schema.Literals<readonly ["human", "model"]>;
+                /** Configured expiry timestamp, or null when absent. */
                 readonly expiresAt: Schema.NullOr<Schema.Int>;
                 /** Original instruction repeated for every occurrence. */
                 readonly prompt: Schema.String;
+                /** Whether the model or a fixed cron cadence schedules occurrences. */
                 readonly mode: Schema.Literals<readonly ["self_paced", "fixed_interval"]>;
                 /** Cadence of a fixed-interval loop; null when the model paces it. */
                 readonly cron: Schema.NullOr<Schema.Struct<{
+                    /** Cron expression for the fixed cadence. */
                     readonly expression: Schema.String;
+                    /** IANA time zone in which the expression is evaluated. */
                     readonly timeZone: Schema.String;
                 }>>;
+                /** Current loop lifecycle state. */
                 readonly state: Schema.Literals<readonly ["active", "paused", "finished", "failed", "cancelled"]>;
                 /** Latest accepted command associated with this loop. */
                 readonly commandId: Schema.String;
@@ -272,20 +332,30 @@ export declare const loopContract: {
             }>;
         };
     };
+    /** Current loop visible to Session clients. */
     readonly projection: {
+        /** Decoder for projected loop state. */
         readonly schema: Schema.Struct<{
-            readonly loop: Schema.NullOr<Schema.Struct<{
+            /** Loop currently visible to Session clients. */
+            readonly loop: Schema.Struct<{
+                /** Identity of the loop whose occurrences are being tracked. */
                 readonly loopId: Schema.String;
+                /** Whether a person or the model started this loop. */
                 readonly origin: Schema.Literals<readonly ["human", "model"]>;
+                /** Configured expiry timestamp, or null when absent. */
                 readonly expiresAt: Schema.NullOr<Schema.Int>;
                 /** Original instruction repeated for every occurrence. */
                 readonly prompt: Schema.String;
+                /** Whether the model or a fixed cron cadence schedules occurrences. */
                 readonly mode: Schema.Literals<readonly ["self_paced", "fixed_interval"]>;
                 /** Cadence of a fixed-interval loop; null when the model paces it. */
                 readonly cron: Schema.NullOr<Schema.Struct<{
+                    /** Cron expression for the fixed cadence. */
                     readonly expression: Schema.String;
+                    /** IANA time zone in which the expression is evaluated. */
                     readonly timeZone: Schema.String;
                 }>>;
+                /** Current loop lifecycle state. */
                 readonly state: Schema.Literals<readonly ["active", "paused", "finished", "failed", "cancelled"]>;
                 /** Latest accepted command associated with this loop. */
                 readonly commandId: Schema.String;
@@ -295,47 +365,6 @@ export declare const loopContract: {
                 readonly nextDueAt: Schema.NullOr<Schema.Int>;
                 /** Visible explanation when loop work failed. */
                 readonly lastError: Schema.NullOr<Schema.String>;
-            }>>;
-            readonly history: Schema.Struct<{
-                readonly nextSequence: Schema.Int;
-                readonly omitted: Schema.Int;
-                readonly events: Schema.$Array<Schema.Struct<{
-                    readonly id: Schema.String;
-                    readonly sequence: Schema.Int;
-                    readonly at: Schema.Int;
-                    readonly commandId: Schema.NullOr<Schema.String>;
-                    readonly event: Schema.Codec<{
-                        readonly loopId: string;
-                        readonly origin: "human" | "model";
-                        readonly expiresAt: number | null;
-                        readonly prompt: string;
-                        readonly mode: "self_paced" | "fixed_interval";
-                        readonly cron: {
-                            readonly expression: string;
-                            readonly timeZone: string;
-                        } | null;
-                        readonly state: "active" | "paused" | "cancelled" | "finished" | "failed";
-                        readonly commandId: string;
-                        readonly reason: string | null;
-                        readonly nextDueAt: number | null;
-                        readonly lastError: string | null;
-                    }, {
-                        readonly loopId: string;
-                        readonly origin: "human" | "model";
-                        readonly expiresAt: number | null;
-                        readonly prompt: string;
-                        readonly mode: "self_paced" | "fixed_interval";
-                        readonly cron: {
-                            readonly expression: string;
-                            readonly timeZone: string;
-                        } | null;
-                        readonly state: "active" | "paused" | "cancelled" | "finished" | "failed";
-                        readonly commandId: string;
-                        readonly reason: string | null;
-                        readonly nextDueAt: number | null;
-                        readonly lastError: string | null;
-                    }, never, never>;
-                }>>;
             }>;
         }>;
     };