@fungi.computer/shiitake-extensions 0.0.2 → 0.1.1

package/README.md

@@ -68,27 +68,46 @@ helper borrows the Agent. Its owner closes it when the host's lifetime ends.
 | Extension | Ownership and behavior                                                                                                                                                                                                                                                                                                                                                                                                                            |
 | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | Ask       | Up to four open decisions per Session. The model asks or withdraws; humans answer or decline. A live waiter receives the answer, while a parked question resumes through one follow-up.                                                                                                                                                                                                                                                           |
-| Goal      | One objective per Session. The model creates, reads and completes it through `goal.*` tools; humans set, pause, resume or clear it. Three tool-less continuations pause it as stalled.                                                                                                                                                                                                                                                            |
+| Goal      | One live or paused objective per Session. The model creates, reads and completes it through `goal.*` tools; humans set, pause, resume or clear it. Esc, failed work, a block or three tool-less continuations pause it. Closing the app pauses it only if work stops without resuming; background work and runtime-auto-resumed turns keep it live. An achieved or cleared goal becomes one chat line in its history.                             |
 | Loop      | One repeated prompt per Session. It runs on a fixed cron cadence or lets its own active run request the next occurrence. Commands start, pause, resume and stop it.                                                                                                                                                                                                                                                                               |
 | Plan      | One checklist per Session. `plan.update_plan` replaces it whole, with at most one step in progress and at most 50 steps; `steps: []` clears it. The human clears it with `/plan clear` or the footer row's Clear plan action, through the same owner. `/plan` opens the full checklist in the footer; updates keep only the current step and progress visible, and a finished or cleared plan leaves the footer while its history stays in state. |
 | Almanac   | Agent-scope one-shot or recurring schedules. Each schedule targets a Session and tracks admission, retry and its next due time.                                                                                                                                                                                                                                                                                                                   |
 | Skills    | Host-supplied, read-only skill discovery. Metadata enters the prompt; `skill.load` reads a skill body or supporting file; `/skills` lists them.                                                                                                                                                                                                                                                                                                   |
 | Home      | Agent-scope choice of an attached Computer. Each run captures its scoped file tools and current attachment choice.                                                                                                                                                                                                                                                                                                                                |
-| Subagents | A read-only footer view: one row per Agent this Session sent work to or created, with its live status (working, waiting on you, idle, failed, unavailable). A row opens that Agent's conversation. It owns no relationship and no durable state.                                                                                                                                                                                                  |
+| Subagents | A read-only footer view: one row per Agent this Session sent work to or created, with its live status (working, waiting on you, idle, failed, unavailable). A row opens that Agent's conversation, and `/agents` collapses the rows to one summary row and expands them again. It owns no relationship and no durable state.                                                                                                                      |
 
 An active Goal is quiet system context on every run. Continuation instructions
 apply only to runs admitted by Goal with its continuation correlation; human
 messages receive the Goal context without that directive. Both sections are
-bounded by UTF-8 bytes. Correlated Goal turns appear as compact transcript
-notes; other extensions keep their own display policy.
+bounded by UTF-8 bytes. Goal turns stay out of the transcript; the footer shows
+only a live goal ("Pursuing goal since 14:02") or a paused one ("Goal paused
+(/goal resume)"), and each finished goal adds one chat line after its last work.
+Other extensions keep their own display policy.
 
 Known limitation: Session forks copy transcript entries without their original
 command-admission rows. Inherited Goal turns therefore lose the extension-origin
 metadata used for compact notes and appear as ordinary message bubbles.
 
 Goal pause stops continuation, not already accepted work. Model-requested
-completion or blocking is provisional until successful settlement. Human
-replacement uses the observed revision to avoid replacing a newer goal.
+completion or blocking is provisional until successful settlement; a blocked
+goal pauses and resumes like any paused goal. Only a live or paused goal asks
+before a replacement, which uses the observed revision to avoid replacing a
+newer goal; the replaced goal is recorded as cleared. When a runtime restart (a
+Hub deploy or eviction, a Local service restart) interrupts a goal turn, the
+turn resumes and the goal stays live. A live goal pauses when any turn of its
+Session fails, cannot resume or is stopped by a person (Esc), including the
+person's own messages ("The last turn failed"). A missing extension origin does
+not establish a human sender; mail and host admissions can also lack one.
+
+Goal's shared wire and durable row use `pauseCause: { kind, detail }` while
+paused and `null` while active. The closed kinds are `person`, `blocked`,
+`stalled`, `cancelled`, `failed`, and `no-terminal`; display detail is nullable
+text, never a discriminator. Only blocked/stalled goals emit `goal-blocked` or
+`goal-stalled` attention, kept out of the main inbox with `inbox: false`.
+Questions and these two Goal kinds ask for a person in Herdr activity;
+person-paused, cancelled and failed goals do not. State version 6 discards
+disposable preview Goal rows from versions 4 and 5 rather than reading the
+superseded representation.
 
 Loop tools are offered in every run. `loop.get`, `loop.start` and `loop.stop`
 work from any run of the Session, and the model may start a loop itself.
@@ -196,7 +215,7 @@ never changes Home. The Session command changes Agent state, so other Sessions
 see that choice on their next run.
 
 Each run captures its table, Home and prompt once. The tools are Knapsack's
-branded `read`, `list`, `glob` and `grep`, with `apply_patch` only when Home's
+branded `read`, `list`, `glob`, and `grep`, with `apply_patch` only when Home's
 port has a native patch engine. Bare paths and `computer://home/` use Home;
 `computer://<name>/` uses another captured attachment. Patches always use Home's
 native engine and path jail. Returned file identity stays owned by the scoped
@@ -238,12 +257,14 @@ not require a provider account or make a provider call.
 ## Subagents
 
 The host creates `subagentsExtension({ source })` and adds `subagentsGrant`
-(`projection` only). `source.read(sessionId, limit)` returns the Agents that
-Session sent work to or created, newest first, with a count of the rest;
-`source.open` is the host's existing Agent access. Each child's status is its
-owner's own Session state: `running` is working, any open attention (a question
-or a tool approval) is waiting on you, `done` is idle and `errored` is failed. A
-child whose state cannot be read is unavailable, never idle.
+(`projection` and `commands`: the human `/agents` command only collapses or
+expands the footer rows, per Session and in memory).
+`source.read(sessionId, limit)` returns the Agents that Session sent work to or
+created, newest first, with a count of the rest; `source.open` is the host's
+existing Agent access. Each child's status is its owner's own Session state:
+`running` is working, any open attention (a question or a tool approval) is
+waiting on you, `done` is idle and `errored` is failed. A child whose state
+cannot be read is unavailable, never idle.
 
 Rows refresh when a watcher reads the parent Session and they are at least a
 second old. While a row is working or waiting, they poll every five seconds
@@ -261,3 +282,12 @@ split.
 
 See [LICENSE](LICENSE) for the license and the package manifest for its public
 repository destination.
+
+## Conversation Agent composition
+
+`@fungi.computer/shiitake-extensions/roster/conversation-agents` supplies the
+shared Local, Hub and Oyster conversation-Agent composition. The host supplies
+its authorized Agent directory and SQLite owner; the roster records accepted
+creates and sends for a read-only footer without granting relationships or
+authority. Storage is prepared lazily. The host remains responsible for creation
+admission, Agent access and resource lifetime.

package/dist/almanac/contract.d.ts

@@ -1,16 +1,22 @@
 import * as Schema from "effect/Schema";
 /** One durable schedule as every caller sees it. */
 export declare const Schedule: Schema.Struct<{
+    /** Caller-chosen schedule identity. */
     readonly id: Schema.String;
+    /** Session that receives each scheduled prompt. */
     readonly sessionId: Schema.String;
+    /** Original prompt submitted to the destination Session. */
     readonly prompt: Schema.String;
     /** Cron expression and zone for a recurring schedule; null for one-shot. */
     readonly cron: Schema.NullOr<Schema.Struct<{
+        /** Cron expression used to calculate occurrences. */
         readonly expression: Schema.String;
+        /** IANA time zone in which the expression is evaluated. */
         readonly timeZone: Schema.String;
     }>>;
     /** The occurrence that fires next (or fired last, once finished). */
     readonly nextDueAt: Schema.Int;
+    /** Current scheduling lifecycle state. */
     readonly state: Schema.Literals<readonly ["active", "paused", "cancelled", "finished"]>;
     /** Latest command admitted for this schedule. */
     readonly lastCommandId: Schema.NullOr<Schema.String>;
@@ -23,27 +29,43 @@ export declare const Schedule: Schema.Struct<{
 export type Schedule = Schema.Schema.Type<typeof Schedule>;
 /** Almanac's contract: agent-scope schedule CRUD, no Session projection. */
 export declare const almanacContract: {
+    /** Stable extension identity. */
     readonly id: string & import("effect/Brand").Brand<"ExtensionId">;
+    /** Agent-scoped schedule operations. */
     readonly commands: {
+        /** Create a schedule with one due occurrence. */
         readonly createOneShot: {
+            /** The Agent owns the schedule collection. */
             readonly scope: "agent";
+            /** Decode the caller's one-shot schedule request. */
             readonly input: Schema.Struct<{
+                /** Caller-chosen schedule identity and create idempotency key. */
                 readonly requestId: Schema.String;
+                /** Session that receives the scheduled prompt. */
                 readonly sessionId: Schema.String;
+                /** Prompt to submit when due. */
                 readonly prompt: Schema.String;
+                /** Due time in epoch milliseconds. */
                 readonly dueAt: Schema.Int;
             }>;
+            /** Return the created durable schedule. */
             readonly output: Schema.Struct<{
+                /** Caller-chosen schedule identity. */
                 readonly id: Schema.String;
+                /** Session that receives each scheduled prompt. */
                 readonly sessionId: Schema.String;
+                /** Original prompt submitted to the destination Session. */
                 readonly prompt: Schema.String;
                 /** Cron expression and zone for a recurring schedule; null for one-shot. */
                 readonly cron: Schema.NullOr<Schema.Struct<{
+                    /** Cron expression used to calculate occurrences. */
                     readonly expression: Schema.String;
+                    /** IANA time zone in which the expression is evaluated. */
                     readonly timeZone: Schema.String;
                 }>>;
                 /** The occurrence that fires next (or fired last, once finished). */
                 readonly nextDueAt: Schema.Int;
+                /** Current scheduling lifecycle state. */
                 readonly state: Schema.Literals<readonly ["active", "paused", "cancelled", "finished"]>;
                 /** Latest command admitted for this schedule. */
                 readonly lastCommandId: Schema.NullOr<Schema.String>;
@@ -53,26 +75,41 @@ export declare const almanacContract: {
                 readonly attempt: Schema.Int;
             }>;
         };
+        /** Create a recurring cron schedule. */
         readonly createRecurring: {
+            /** The Agent owns the schedule collection. */
             readonly scope: "agent";
+            /** Decode the caller's recurring schedule request. */
             readonly input: Schema.Struct<{
+                /** Caller-chosen schedule identity and create idempotency key. */
                 readonly requestId: Schema.String;
+                /** Session that receives each occurrence. */
                 readonly sessionId: Schema.String;
+                /** Prompt repeated for each occurrence. */
                 readonly prompt: Schema.String;
+                /** Cron expression used to calculate occurrences. */
                 readonly expression: Schema.String;
+                /** IANA time zone used to evaluate the cron expression. */
                 readonly timeZone: Schema.String;
             }>;
+            /** Return the created durable schedule. */
             readonly output: Schema.Struct<{
+                /** Caller-chosen schedule identity. */
                 readonly id: Schema.String;
+                /** Session that receives each scheduled prompt. */
                 readonly sessionId: Schema.String;
+                /** Original prompt submitted to the destination Session. */
                 readonly prompt: Schema.String;
                 /** Cron expression and zone for a recurring schedule; null for one-shot. */
                 readonly cron: Schema.NullOr<Schema.Struct<{
+                    /** Cron expression used to calculate occurrences. */
                     readonly expression: Schema.String;
+                    /** IANA time zone in which the expression is evaluated. */
                     readonly timeZone: Schema.String;
                 }>>;
                 /** The occurrence that fires next (or fired last, once finished). */
                 readonly nextDueAt: Schema.Int;
+                /** Current scheduling lifecycle state. */
                 readonly state: Schema.Literals<readonly ["active", "paused", "cancelled", "finished"]>;
                 /** Latest command admitted for this schedule. */
                 readonly lastCommandId: Schema.NullOr<Schema.String>;
@@ -82,22 +119,33 @@ export declare const almanacContract: {
                 readonly attempt: Schema.Int;
             }>;
         };
+        /** Read one schedule, or null when absent. */
         readonly read: {
+            /** Read from the Agent's schedule collection. */
             readonly scope: "agent";
+            /** Identify the schedule to read. */
             readonly input: Schema.Struct<{
+                /** Existing schedule targeted by the command. */
                 readonly scheduleId: Schema.String;
             }>;
+            /** Decode the schedule or its absence. */
             readonly output: Schema.NullOr<Schema.Struct<{
+                /** Caller-chosen schedule identity. */
                 readonly id: Schema.String;
+                /** Session that receives each scheduled prompt. */
                 readonly sessionId: Schema.String;
+                /** Original prompt submitted to the destination Session. */
                 readonly prompt: Schema.String;
                 /** Cron expression and zone for a recurring schedule; null for one-shot. */
                 readonly cron: Schema.NullOr<Schema.Struct<{
+                    /** Cron expression used to calculate occurrences. */
                     readonly expression: Schema.String;
+                    /** IANA time zone in which the expression is evaluated. */
                     readonly timeZone: Schema.String;
                 }>>;
                 /** The occurrence that fires next (or fired last, once finished). */
                 readonly nextDueAt: Schema.Int;
+                /** Current scheduling lifecycle state. */
                 readonly state: Schema.Literals<readonly ["active", "paused", "cancelled", "finished"]>;
                 /** Latest command admitted for this schedule. */
                 readonly lastCommandId: Schema.NullOr<Schema.String>;
@@ -107,23 +155,35 @@ export declare const almanacContract: {
                 readonly attempt: Schema.Int;
             }>>;
         };
+        /** Read a bounded page of schedules after an optional identity. */
         readonly list: {
+            /** Read from the Agent's schedule collection. */
             readonly scope: "agent";
+            /** Decode pagination arguments. */
             readonly input: Schema.Struct<{
+                /** Exclusive schedule cursor. */
                 readonly after: Schema.optionalKey<Schema.String>;
+                /** Maximum number of schedules returned. */
                 readonly limit: Schema.optionalKey<Schema.Int>;
             }>;
+            /** Decode the returned schedule rows. */
             readonly output: Schema.$Array<Schema.Struct<{
+                /** Caller-chosen schedule identity. */
                 readonly id: Schema.String;
+                /** Session that receives each scheduled prompt. */
                 readonly sessionId: Schema.String;
+                /** Original prompt submitted to the destination Session. */
                 readonly prompt: Schema.String;
                 /** Cron expression and zone for a recurring schedule; null for one-shot. */
                 readonly cron: Schema.NullOr<Schema.Struct<{
+                    /** Cron expression used to calculate occurrences. */
                     readonly expression: Schema.String;
+                    /** IANA time zone in which the expression is evaluated. */
                     readonly timeZone: Schema.String;
                 }>>;
                 /** The occurrence that fires next (or fired last, once finished). */
                 readonly nextDueAt: Schema.Int;
+                /** Current scheduling lifecycle state. */
                 readonly state: Schema.Literals<readonly ["active", "paused", "cancelled", "finished"]>;
                 /** Latest command admitted for this schedule. */
                 readonly lastCommandId: Schema.NullOr<Schema.String>;
@@ -133,22 +193,33 @@ export declare const almanacContract: {
                 readonly attempt: Schema.Int;
             }>>;
         };
+        /** Suspend future occurrences of a schedule. */
         readonly pause: {
+            /** The Agent owns the schedule. */
             readonly scope: "agent";
+            /** Identify the schedule to pause. */
             readonly input: Schema.Struct<{
+                /** Existing schedule targeted by the command. */
                 readonly scheduleId: Schema.String;
             }>;
+            /** Return its updated state. */
             readonly output: Schema.Struct<{
+                /** Caller-chosen schedule identity. */
                 readonly id: Schema.String;
+                /** Session that receives each scheduled prompt. */
                 readonly sessionId: Schema.String;
+                /** Original prompt submitted to the destination Session. */
                 readonly prompt: Schema.String;
                 /** Cron expression and zone for a recurring schedule; null for one-shot. */
                 readonly cron: Schema.NullOr<Schema.Struct<{
+                    /** Cron expression used to calculate occurrences. */
                     readonly expression: Schema.String;
+                    /** IANA time zone in which the expression is evaluated. */
                     readonly timeZone: Schema.String;
                 }>>;
                 /** The occurrence that fires next (or fired last, once finished). */
                 readonly nextDueAt: Schema.Int;
+                /** Current scheduling lifecycle state. */
                 readonly state: Schema.Literals<readonly ["active", "paused", "cancelled", "finished"]>;
                 /** Latest command admitted for this schedule. */
                 readonly lastCommandId: Schema.NullOr<Schema.String>;
@@ -158,22 +229,33 @@ export declare const almanacContract: {
                 readonly attempt: Schema.Int;
             }>;
         };
+        /** Restore a paused schedule to active scheduling. */
         readonly resume: {
+            /** The Agent owns the schedule. */
             readonly scope: "agent";
+            /** Identify the schedule to resume. */
             readonly input: Schema.Struct<{
+                /** Existing schedule targeted by the command. */
                 readonly scheduleId: Schema.String;
             }>;
+            /** Return its updated state. */
             readonly output: Schema.Struct<{
+                /** Caller-chosen schedule identity. */
                 readonly id: Schema.String;
+                /** Session that receives each scheduled prompt. */
                 readonly sessionId: Schema.String;
+                /** Original prompt submitted to the destination Session. */
                 readonly prompt: Schema.String;
                 /** Cron expression and zone for a recurring schedule; null for one-shot. */
                 readonly cron: Schema.NullOr<Schema.Struct<{
+                    /** Cron expression used to calculate occurrences. */
                     readonly expression: Schema.String;
+                    /** IANA time zone in which the expression is evaluated. */
                     readonly timeZone: Schema.String;
                 }>>;
                 /** The occurrence that fires next (or fired last, once finished). */
                 readonly nextDueAt: Schema.Int;
+                /** Current scheduling lifecycle state. */
                 readonly state: Schema.Literals<readonly ["active", "paused", "cancelled", "finished"]>;
                 /** Latest command admitted for this schedule. */
                 readonly lastCommandId: Schema.NullOr<Schema.String>;
@@ -183,22 +265,33 @@ export declare const almanacContract: {
                 readonly attempt: Schema.Int;
             }>;
         };
+        /** Cancel future occurrences of a schedule. */
         readonly cancel: {
+            /** The Agent owns the schedule. */
             readonly scope: "agent";
+            /** Identify the schedule to cancel. */
             readonly input: Schema.Struct<{
+                /** Existing schedule targeted by the command. */
                 readonly scheduleId: Schema.String;
             }>;
+            /** Return its updated state. */
             readonly output: Schema.Struct<{
+                /** Caller-chosen schedule identity. */
                 readonly id: Schema.String;
+                /** Session that receives each scheduled prompt. */
                 readonly sessionId: Schema.String;
+                /** Original prompt submitted to the destination Session. */
                 readonly prompt: Schema.String;
                 /** Cron expression and zone for a recurring schedule; null for one-shot. */
                 readonly cron: Schema.NullOr<Schema.Struct<{
+                    /** Cron expression used to calculate occurrences. */
                     readonly expression: Schema.String;
+                    /** IANA time zone in which the expression is evaluated. */
                     readonly timeZone: Schema.String;
                 }>>;
                 /** The occurrence that fires next (or fired last, once finished). */
                 readonly nextDueAt: Schema.Int;
+                /** Current scheduling lifecycle state. */
                 readonly state: Schema.Literals<readonly ["active", "paused", "cancelled", "finished"]>;
                 /** Latest command admitted for this schedule. */
                 readonly lastCommandId: Schema.NullOr<Schema.String>;
@@ -209,5 +302,6 @@ export declare const almanacContract: {
             }>;
         };
     };
+    /** Almanac has no Session projection. */
     readonly projection: null;
 };

package/dist/almanac/contract.js

@@ -15,13 +15,22 @@ const CronExpression = Schema.String.pipe(Schema.check(Schema.isMinLength(1)), S
 const TimeZone = Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.isMaxLength(128)));
 /** One durable schedule as every caller sees it. */
 export const Schedule = Schema.Struct({
+    /** Caller-chosen schedule identity. */
     id: ScheduleId,
+    /** Session that receives each scheduled prompt. */
     sessionId: SessionId,
+    /** Original prompt submitted to the destination Session. */
     prompt: Prompt,
     /** Cron expression and zone for a recurring schedule; null for one-shot. */
-    cron: Schema.NullOr(Schema.Struct({ expression: CronExpression, timeZone: TimeZone })),
+    cron: Schema.NullOr(Schema.Struct({
+        /** Cron expression used to calculate occurrences. */
+        expression: CronExpression,
+        /** IANA time zone in which the expression is evaluated. */
+        timeZone: TimeZone,
+    })),
     /** The occurrence that fires next (or fired last, once finished). */
     nextDueAt: Instant,
+    /** Current scheduling lifecycle state. */
     state: Schema.Literals(["active", "paused", "cancelled", "finished"]),
     /** Latest command admitted for this schedule. */
     lastCommandId: Schema.NullOr(Schema.String),
@@ -30,48 +39,105 @@ export const Schedule = Schema.Struct({
     /** Consecutive failed admissions of the current occurrence. */
     attempt: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0))),
 });
-const ScheduleRef = Schema.Struct({ scheduleId: ScheduleId });
+const ScheduleRef = Schema.Struct({
+    /** Existing schedule targeted by the command. */
+    scheduleId: ScheduleId,
+});
 /** Almanac's contract: agent-scope schedule CRUD, no Session projection. */
 export const almanacContract = {
+    /** Stable extension identity. */
     id: ExtensionId.make("botanical-almanac"),
+    /** Agent-scoped schedule operations. */
     commands: {
+        /** Create a schedule with one due occurrence. */
         createOneShot: {
+            /** The Agent owns the schedule collection. */
             scope: "agent",
+            /** Decode the caller's one-shot schedule request. */
             input: Schema.Struct({
+                /** Caller-chosen schedule identity and create idempotency key. */
                 requestId: ScheduleId,
+                /** Session that receives the scheduled prompt. */
                 sessionId: SessionId,
+                /** Prompt to submit when due. */
                 prompt: Prompt,
+                /** Due time in epoch milliseconds. */
                 dueAt: Instant,
             }),
+            /** Return the created durable schedule. */
             output: Schedule,
         },
+        /** Create a recurring cron schedule. */
         createRecurring: {
+            /** The Agent owns the schedule collection. */
             scope: "agent",
+            /** Decode the caller's recurring schedule request. */
             input: Schema.Struct({
+                /** Caller-chosen schedule identity and create idempotency key. */
                 requestId: ScheduleId,
+                /** Session that receives each occurrence. */
                 sessionId: SessionId,
+                /** Prompt repeated for each occurrence. */
                 prompt: Prompt,
+                /** Cron expression used to calculate occurrences. */
                 expression: CronExpression,
+                /** IANA time zone used to evaluate the cron expression. */
                 timeZone: TimeZone,
             }),
+            /** Return the created durable schedule. */
             output: Schedule,
         },
+        /** Read one schedule, or null when absent. */
         read: {
+            /** Read from the Agent's schedule collection. */
             scope: "agent",
+            /** Identify the schedule to read. */
             input: ScheduleRef,
+            /** Decode the schedule or its absence. */
             output: Schema.NullOr(Schedule),
         },
+        /** Read a bounded page of schedules after an optional identity. */
         list: {
+            /** Read from the Agent's schedule collection. */
             scope: "agent",
+            /** Decode pagination arguments. */
             input: Schema.Struct({
+                /** Exclusive schedule cursor. */
                 after: Schema.optionalKey(ScheduleId),
+                /** Maximum number of schedules returned. */
                 limit: Schema.optionalKey(Schema.Int.pipe(Schema.check(Schema.isBetween({ minimum: 1, maximum: 64 })))),
             }),
+            /** Decode the returned schedule rows. */
             output: Schema.Array(Schedule),
         },
-        pause: { scope: "agent", input: ScheduleRef, output: Schedule },
-        resume: { scope: "agent", input: ScheduleRef, output: Schedule },
-        cancel: { scope: "agent", input: ScheduleRef, output: Schedule },
+        /** Suspend future occurrences of a schedule. */
+        pause: {
+            /** The Agent owns the schedule. */
+            scope: "agent",
+            /** Identify the schedule to pause. */
+            input: ScheduleRef,
+            /** Return its updated state. */
+            output: Schedule,
+        },
+        /** Restore a paused schedule to active scheduling. */
+        resume: {
+            /** The Agent owns the schedule. */
+            scope: "agent",
+            /** Identify the schedule to resume. */
+            input: ScheduleRef,
+            /** Return its updated state. */
+            output: Schedule,
+        },
+        /** Cancel future occurrences of a schedule. */
+        cancel: {
+            /** The Agent owns the schedule. */
+            scope: "agent",
+            /** Identify the schedule to cancel. */
+            input: ScheduleRef,
+            /** Return its updated state. */
+            output: Schedule,
+        },
     },
+    /** Almanac has no Session projection. */
     projection: null,
 };

package/dist/goal/client.d.ts

@@ -1,9 +1,12 @@
 import { type ClientContributionV1 } from "@fungi.computer/shiitake/client-entry";
-/** Product copy and controls belong to Goal; every host renders plain rows. */
+/**
+ * Product copy and controls belong to Goal; every host renders plain rows.
+ * The footer shows only a live or paused goal; finished goals are chat lines.
+ */
 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;
 }>;