@fungi.computer/shiitake-extensions 0.5.0 → 0.6.0

package/dist/loop/contract.d.ts

@@ -1,45 +1,5 @@
 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;
-    /** The model's stated reason for the next self-paced occurrence. */
-    readonly reason: Schema.NullOr<Schema.String>;
-    /** When the next occurrence is due, if one is scheduled. */
-    readonly nextDueAt: Schema.NullOr<Schema.Int>;
-    /** Visible explanation when loop work failed. */
-    readonly lastError: Schema.NullOr<Schema.String>;
-    /** Consecutive failed work outcomes; successful work resets this to zero. */
-    readonly consecutiveFailures: Schema.Int;
-}>;
-/** One Session's loop. */
-export type Loop = Schema.Schema.Type<typeof Loop>;
+export { Loop, LoopCron } from "./schema.js";
 /**
  * Arguments of the human `/loop` command. `start` carries the typed text:
  * `<prompt>` paces itself, `<N>m <prompt>` or `<N>h <prompt>` runs on an
@@ -62,34 +22,20 @@ export declare const LoopCommandInput: Schema.Union<readonly [Schema.Struct<{
 export declare const LoopProjection: 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;
-        /** The model's stated reason for the next self-paced occurrence. */
         readonly reason: Schema.NullOr<Schema.String>;
-        /** When the next occurrence is due, if one is scheduled. */
         readonly nextDueAt: Schema.NullOr<Schema.Int>;
-        /** Visible explanation when loop work failed. */
         readonly lastError: Schema.NullOr<Schema.String>;
-        /** Consecutive failed work outcomes; successful work resets this to zero. */
         readonly consecutiveFailures: Schema.Int;
     }>;
 }>;
@@ -105,43 +51,27 @@ export declare const loopContract: {
             readonly scope: "agent";
             /** Page strictly after a Session identity, in identity order. */
             readonly input: Schema.Struct<{
-                /** Exclusive Session cursor. */
                 readonly after: Schema.optionalKey<Schema.String>;
-                /** Maximum number of Loop rows to read. */
                 readonly limit: Schema.optionalKey<Schema.Int>;
             }>;
             /** Public Loop values with Session targets, never private scheduling state. */
             readonly output: Schema.$Array<Schema.Struct<{
                 /** Session that owns this identified Loop. */
                 readonly sessionId: Schema.String;
-                /** 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;
-                /** The model's stated reason for the next self-paced occurrence. */
                 readonly reason: Schema.NullOr<Schema.String>;
-                /** When the next occurrence is due, if one is scheduled. */
                 readonly nextDueAt: Schema.NullOr<Schema.Int>;
-                /** Visible explanation when loop work failed. */
                 readonly lastError: Schema.NullOr<Schema.String>;
-                /** Consecutive failed work outcomes; successful work resets this to zero. */
                 readonly consecutiveFailures: Schema.Int;
             }>>;
         };
@@ -158,34 +88,50 @@ export declare const loopContract: {
             }>;
             /** Return the paused Loop without cancelling accepted work. */
             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;
-                /** The model's stated reason for the next self-paced occurrence. */
                 readonly reason: Schema.NullOr<Schema.String>;
-                /** When the next occurrence is due, if one is scheduled. */
                 readonly nextDueAt: Schema.NullOr<Schema.Int>;
-                /** Visible explanation when loop work failed. */
                 readonly lastError: Schema.NullOr<Schema.String>;
-                /** Consecutive failed work outcomes; successful work resets this to zero. */
+                readonly consecutiveFailures: Schema.Int;
+            }>;
+        };
+        /** Resume an identified Loop; refuse a stale target after replacement. */
+        readonly resumeLoop: {
+            /** The Agent owns the identified Loop and its Session. */
+            readonly scope: "agent";
+            /** The listed Session and Loop identities must both still match. */
+            readonly input: Schema.Struct<{
+                /** Session containing the identified Loop. */
+                readonly sessionId: Schema.String;
+                /** Exact Loop identity, not whichever Loop later replaces it. */
+                readonly loopId: Schema.String;
+            }>;
+            /** Return the resumed Loop without changing accepted work. */
+            readonly output: Schema.Struct<{
+                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;
             }>;
         };
@@ -202,34 +148,20 @@ export declare const loopContract: {
             }>;
             /** Return the cancelled Loop; its Session and history remain. */
             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;
-                /** The model's stated reason for the next self-paced occurrence. */
                 readonly reason: Schema.NullOr<Schema.String>;
-                /** When the next occurrence is due, if one is scheduled. */
                 readonly nextDueAt: Schema.NullOr<Schema.Int>;
-                /** Visible explanation when loop work failed. */
                 readonly lastError: Schema.NullOr<Schema.String>;
-                /** Consecutive failed work outcomes; successful work resets this to zero. */
                 readonly consecutiveFailures: Schema.Int;
             }>;
         };
@@ -269,34 +201,20 @@ export declare const loopContract: {
             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;
-                    /** The model's stated reason for the next self-paced occurrence. */
                     readonly reason: Schema.NullOr<Schema.String>;
-                    /** When the next occurrence is due, if one is scheduled. */
                     readonly nextDueAt: Schema.NullOr<Schema.Int>;
-                    /** Visible explanation when loop work failed. */
                     readonly lastError: Schema.NullOr<Schema.String>;
-                    /** Consecutive failed work outcomes; successful work resets this to zero. */
                     readonly consecutiveFailures: Schema.Int;
                 }>;
                 /** Admission receipt for the start command. */
@@ -314,9 +232,7 @@ export declare const loopContract: {
             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;
@@ -327,34 +243,20 @@ export declare const loopContract: {
             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;
-                    /** The model's stated reason for the next self-paced occurrence. */
                     readonly reason: Schema.NullOr<Schema.String>;
-                    /** When the next occurrence is due, if one is scheduled. */
                     readonly nextDueAt: Schema.NullOr<Schema.Int>;
-                    /** Visible explanation when loop work failed. */
                     readonly lastError: Schema.NullOr<Schema.String>;
-                    /** Consecutive failed work outcomes; successful work resets this to zero. */
                     readonly consecutiveFailures: Schema.Int;
                 }>;
                 /** Admission receipt for the start command. */
@@ -374,34 +276,20 @@ export declare const loopContract: {
             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;
-                /** The model's stated reason for the next self-paced occurrence. */
                 readonly reason: Schema.NullOr<Schema.String>;
-                /** When the next occurrence is due, if one is scheduled. */
                 readonly nextDueAt: Schema.NullOr<Schema.Int>;
-                /** Visible explanation when loop work failed. */
                 readonly lastError: Schema.NullOr<Schema.String>;
-                /** Consecutive failed work outcomes; successful work resets this to zero. */
                 readonly consecutiveFailures: Schema.Int;
             }>;
         };
@@ -413,34 +301,20 @@ export declare const loopContract: {
             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;
-                /** The model's stated reason for the next self-paced occurrence. */
                 readonly reason: Schema.NullOr<Schema.String>;
-                /** When the next occurrence is due, if one is scheduled. */
                 readonly nextDueAt: Schema.NullOr<Schema.Int>;
-                /** Visible explanation when loop work failed. */
                 readonly lastError: Schema.NullOr<Schema.String>;
-                /** Consecutive failed work outcomes; successful work resets this to zero. */
                 readonly consecutiveFailures: Schema.Int;
             }>;
         };
@@ -452,34 +326,20 @@ export declare const loopContract: {
             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;
-                /** The model's stated reason for the next self-paced occurrence. */
                 readonly reason: Schema.NullOr<Schema.String>;
-                /** When the next occurrence is due, if one is scheduled. */
                 readonly nextDueAt: Schema.NullOr<Schema.Int>;
-                /** Visible explanation when loop work failed. */
                 readonly lastError: Schema.NullOr<Schema.String>;
-                /** Consecutive failed work outcomes; successful work resets this to zero. */
                 readonly consecutiveFailures: Schema.Int;
             }>;
         };
@@ -490,34 +350,20 @@ export declare const loopContract: {
         readonly schema: 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;
-                /** The model's stated reason for the next self-paced occurrence. */
                 readonly reason: Schema.NullOr<Schema.String>;
-                /** When the next occurrence is due, if one is scheduled. */
                 readonly nextDueAt: Schema.NullOr<Schema.Int>;
-                /** Visible explanation when loop work failed. */
                 readonly lastError: Schema.NullOr<Schema.String>;
-                /** Consecutive failed work outcomes; successful work resets this to zero. */
                 readonly consecutiveFailures: Schema.Int;
             }>;
         }>;

package/dist/loop/contract.js

@@ -1,54 +1,15 @@
 import { ExtensionId } from "@fungi.computer/shiitake/extensions";
 import * as Schema from "effect/Schema";
 import { CatalogStep } from "../internal/catalog.js";
+import { Prompt, SessionId } from "../internal/schedule-fields.js";
+import { LoopCron, Loop, LoopListInput } from "./schema.js";
+export { Loop, LoopCron } from "./schema.js";
 /**
  * Session loop: one repeated prompt per Session, either paced by the model
  * (`schedule_next`) or by a fixed cron cadence. Shared by the server
  * extension and every client; its schemas are the one decoder.
  */
-const Prompt = Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.isMaxLength(256 * 1024)));
 const RequestId = Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.isMaxLength(200)));
-const SessionId = Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.isMaxLength(256)));
-/** 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))),
-});
 const StartResult = Schema.Struct({
     /** Newly started loop. */
     loop: Loop,
@@ -111,12 +72,7 @@ export const loopContract = {
             /** The Agent owns the collection of its Sessions' Loops. */
             scope: "agent",
             /** Page strictly after a Session identity, in identity order. */
-            input: 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 })))),
-            }),
+            input: LoopListInput,
             /** Public Loop values with Session targets, never private scheduling state. */
             output: Schema.Array(Schema.Struct({
                 ...Loop.fields,
@@ -133,6 +89,15 @@ export const loopContract = {
             /** Return the paused Loop without cancelling accepted work. */
             output: Loop,
         },
+        /** Resume an identified Loop; refuse a stale target after replacement. */
+        resumeLoop: {
+            /** The Agent owns the identified Loop and its Session. */
+            scope: "agent",
+            /** The listed Session and Loop identities must both still match. */
+            input: LoopTarget,
+            /** Return the resumed Loop without changing accepted work. */
+            output: Loop,
+        },
         /** Cancel an identified Loop's future occurrences, retaining accepted work. */
         stopLoop: {
             /** The Agent owns the identified Loop and its Session. */

package/dist/loop/host.js

@@ -506,7 +506,9 @@ function controlIdentifiedLoop(ctx, target, action) {
         ? Effect.fail(conflict("Session loop has been replaced"))
         : action === "pause"
             ? pauseLoop(ctx, target.sessionId)
-            : stopLoop(ctx, target.sessionId)));
+            : action === "resume"
+                ? resumeLoop(ctx, target.sessionId)
+                : stopLoop(ctx, target.sessionId)));
 }
 function cronForInterval(value, unit) {
     if (unit === "m" || unit === "min")
@@ -678,6 +680,7 @@ export const loopExtension = defineExtension({
         specs: loopContract.commands,
         handlers: (ctx) => ({
             pauseLoop: ({ input }) => controlIdentifiedLoop(ctx, input, "pause"),
+            resumeLoop: ({ input }) => controlIdentifiedLoop(ctx, input, "resume"),
             stopLoop: ({ input }) => controlIdentifiedLoop(ctx, input, "stop"),
             list: ({ input }) => ctx.state.loops
                 .page({ after: input.after, limit: input.limit ?? 64 })

package/dist/loop/schema.d.ts

@@ -0,0 +1,49 @@
+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;
+    /** The model's stated reason for the next self-paced occurrence. */
+    readonly reason: Schema.NullOr<Schema.String>;
+    /** When the next occurrence is due, if one is scheduled. */
+    readonly nextDueAt: Schema.NullOr<Schema.Int>;
+    /** Visible explanation when loop work failed. */
+    readonly lastError: Schema.NullOr<Schema.String>;
+    /** Consecutive failed work outcomes; successful work resets this to zero. */
+    readonly consecutiveFailures: Schema.Int;
+}>;
+/** One Session's loop. */
+export type Loop = Schema.Schema.Type<typeof Loop>;
+/** Native bounded Loop page grammar, also used by shared continuations. */
+export declare const LoopListInput: Schema.Struct<{
+    /** Exclusive Session cursor. */
+    readonly after: Schema.optionalKey<Schema.String>;
+    /** Maximum number of Loop rows to read. */
+    readonly limit: Schema.optionalKey<Schema.Int>;
+}>;

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 })))),
+});