@fungi.computer/shiitake-extensions 0.3.0 → 0.5.0

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

@@ -1,9 +1,29 @@
 import { type AgentControlDirectory } from "@fungi.computer/shiitake/agent-control";
 import type { CapabilitySource } from "@fungi.computer/mycelium";
+import { type ShiitakeSession } from "@fungi.computer/shiitake/client";
 import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
 import type { SubagentSource } from "../subagents/host.js";
 /** Host-pack creation admission; attachments/model selection retain their own owners. */
 export declare function assertOrdinaryAgentCreation(input: Parameters<NonNullable<AgentControlDirectory["create"]>>[0]): void;
+/** The directory a conversation sends through; opening a recipient only needs its Sessions' extension doors. */
+export type SendingDirectory = Omit<AgentControlDirectory, "open"> & Readonly<{
+    /** Open the recipient's Session extension door for goal adoption. */
+    open: (agentId: string, signal: AbortSignal) => Promise<Readonly<{
+        /** Recipient Agent with a Session extension door. */
+        agent: Readonly<{
+            /** Address a recipient Session without loading its conversation. */
+            session: (sessionId: string) => Pick<ShiitakeSession, "extension">;
+        }>;
+        /** Release the acquired recipient without stopping its work. */
+        release: () => Promise<void>;
+    }>>;
+}>;
+/** Adopt the first accepted turn once, even when the sender was offline at delivery. */
+export declare function adoptDelegatedGoal(session: Pick<ShiitakeSession, "extension">, input: Readonly<{
+    text: string;
+    goal: string | false | undefined;
+    commandId: string;
+}>): Promise<void>;
 /**
  * This host's own record of the Agents each conversation created or sent
  * accepted work to, written as its Agent-control directory accepts them
@@ -14,7 +34,7 @@ export declare function assertOrdinaryAgentCreation(input: Parameters<NonNullabl
  */
 export declare function createConversationAgents(storage: WatchdogSqliteOwner): {
     /** Bind acceptance recording to this conversation's existing directory. */
-    recording: (parentSessionId: string | undefined, directory: AgentControlDirectory) => AgentControlDirectory;
+    recording: <Directory extends SendingDirectory>(parentSessionId: string | undefined, directory: Directory) => Directory;
     /** Agent-control tools bound to the conversation that acquires them. */
     control: (directoryFor: (parentSessionId: string | undefined) => AgentControlDirectory) => CapabilitySource;
     /** The footer rows for one conversation; archived and unknown Agents leave it. */

package/dist/roster/conversation-agents.js

@@ -1,7 +1,9 @@
 import { AgentCreateRefused, createAgentControlSource, } from "@fungi.computer/shiitake/agent-control";
+import { bindSessionExtension, } from "@fungi.computer/shiitake/client";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
 import { botanicalAgentExtensions, botanicalExtensionsWithSubagents, } from "../roster.js";
+import { goalContract } from "../goal/contract.js";
 /** Host-pack creation admission; attachments/model selection retain their own owners. */
 export function assertOrdinaryAgentCreation(input) {
     if (input.model !== undefined)
@@ -25,6 +27,28 @@ const delegatedCommandRow = Schema.Struct({
 const maxWatchedCommands = 64;
 const pollMs = 2_000;
 const maxWatchMs = 30 * 60_000;
+/** The objective of a delegated lane: the named goal, else the send's first line. */
+function laneObjective(text, goal) {
+    const named = goal?.trim();
+    if (named !== undefined && named !== "")
+        return named;
+    return (text
+        .split("\n")
+        .map((line) => line.trim())
+        .find((line) => line !== "") ?? text.trim()).slice(0, 4_000);
+}
+/** Adopt the first accepted turn once, even when the sender was offline at delivery. */
+export async function adoptDelegatedGoal(session, input) {
+    if (input.goal === false)
+        return;
+    await bindSessionExtension(session, goalContract).call("set", {
+        objective: laneObjective(input.text, input.goal),
+        expectedRevision: null,
+        requestId: `lane-goal:${input.commandId}`,
+        // The delegated prompt is already admitted; never enqueue it twice.
+        adoptCommandId: input.commandId,
+    });
+}
 /**
  * This host's own record of the Agents each conversation created or sent
  * accepted work to, written as its Agent-control directory accepts them
@@ -75,8 +99,29 @@ export function createConversationAgents(storage) {
                 ...recorded,
                 send: async (task, sourceSessionId, signal, invocation) => {
                     const accepted = await send(task, sourceSessionId, signal, invocation);
-                    if (accepted.status === "accepted")
-                        sent(sourceSessionId, task.agentId, accepted.sessionId ?? task.sessionId, accepted.commandId);
+                    if (accepted.status === "accepted") {
+                        const sessionId = accepted.sessionId ?? task.sessionId;
+                        sent(sourceSessionId, task.agentId, sessionId, accepted.commandId);
+                        // A send that opens a new Session puts it under a goal, so the
+                        // lane keeps working until it reports complete or blocked. A
+                        // retry replays the same request id, so the goal is set once.
+                        if (task.delivery === "followUp" &&
+                            task.sessionId === undefined &&
+                            task.goal !== false &&
+                            sessionId !== undefined) {
+                            const opened = await directory.open(task.agentId, signal);
+                            try {
+                                await adoptDelegatedGoal(opened.agent.session(sessionId), {
+                                    text: task.text,
+                                    goal: task.goal,
+                                    commandId: accepted.commandId,
+                                });
+                            }
+                            finally {
+                                await opened.release();
+                            }
+                        }
+                    }
                     return accepted;
                 },
             };

package/dist/roster.d.ts

@@ -2,11 +2,14 @@ import type { ExtensionRosterV0 } from "@fungi.computer/shiitake/extensions";
 import type { SkillSource } from "./skills/source.js";
 import { type SubagentSource } from "./subagents/host.js";
 /**
- * Botanical's product roster with explicit grants. Hub and Local pass this
- * same value; a stranger host passes its own (or an empty) roster.
+ * Botanical's shared roster with explicit grants. Local composes its
+ * sender-routing question extension through `botanicalExtensionsWithSkills`;
+ * hosts without that Local capability send every Ask to a person.
  */
 export declare const botanicalAgentExtensions: ExtensionRosterV0;
 /** Compose the goal and footer over one source; an absent goal is a wiring error. */
 export declare function botanicalExtensionsWithSubagents(base: ExtensionRosterV0, source: SubagentSource): ExtensionRosterV0;
 /** A host with a SkillSource grants read-only skill discovery for its own runs. */
 export declare function botanicalExtensionsWithSkills(source: SkillSource): ExtensionRosterV0;
+/** Route Asks to the Agent that sent the work, only in a host that owns the Local answer door. */
+export declare function botanicalExtensionsWithSenderRouting(): ExtensionRosterV0;

package/dist/roster.js

@@ -1,7 +1,7 @@
 import { almanacContract } from "./almanac/contract.js";
 import { almanacExtension } from "./almanac/host.js";
 import { questionContract } from "./question/contract.js";
-import { questionExtension } from "./question/host.js";
+import { localQuestionExtension, questionExtension } from "./question/host.js";
 import { goalContract } from "./goal/contract.js";
 import { goalExtension, goalExtensionFor } from "./goal/host.js";
 import { loopContract } from "./loop/contract.js";
@@ -11,8 +11,9 @@ import { planExtension } from "./plan/host.js";
 import { skillsExtension, skillsGrant } from "./skills/host.js";
 import { subagentsExtension, subagentsGrant, } from "./subagents/host.js";
 /**
- * Botanical's product roster with explicit grants. Hub and Local pass this
- * same value; a stranger host passes its own (or an empty) roster.
+ * Botanical's shared roster with explicit grants. Local composes its
+ * sender-routing question extension through `botanicalExtensionsWithSkills`;
+ * hosts without that Local capability send every Ask to a person.
  */
 export const botanicalAgentExtensions = Object.freeze({
     roster: Object.freeze([
@@ -90,8 +91,18 @@ export function botanicalExtensionsWithSubagents(base, source) {
 }
 /** A host with a SkillSource grants read-only skill discovery for its own runs. */
 export function botanicalExtensionsWithSkills(source) {
+    const local = botanicalExtensionsWithSenderRouting();
     return {
-        roster: [...botanicalAgentExtensions.roster, skillsExtension({ source })],
-        grants: [...botanicalAgentExtensions.grants, skillsGrant],
+        roster: [...local.roster, skillsExtension({ source })],
+        grants: [...local.grants, skillsGrant],
+    };
+}
+/** Route Asks to the Agent that sent the work, only in a host that owns the Local answer door. */
+export function botanicalExtensionsWithSenderRouting() {
+    return {
+        ...botanicalAgentExtensions,
+        roster: botanicalAgentExtensions.roster.map((extension) => extension.manifest.id === questionContract.id
+            ? localQuestionExtension
+            : extension),
     };
 }

package/dist/schedules.d.ts

@@ -0,0 +1,178 @@
+import type { ShiitakeAgent } from "@fungi.computer/shiitake";
+import * as Schema from "effect/Schema";
+import { z } from "zod";
+/** Exclusive native key within one Agent's Almanac-then-Loop traversal. */
+export declare const agentScheduleCursorSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    kind: z.ZodUnion<readonly [z.ZodLiteral<"almanac">, z.ZodLiteral<"loop">]>;
+    after: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** One bounded read; a full native page conservatively carries continuation. */
+export declare const agentScheduleListInputSchema: z.ZodObject<{
+    after: z.ZodOptional<z.ZodObject<{
+        agentId: z.ZodString;
+        kind: z.ZodUnion<readonly [z.ZodLiteral<"almanac">, z.ZodLiteral<"loop">]>;
+        after: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+/** Content-bearing read projection, decoded by the retained native contracts. */
+export declare const agentScheduleRowSchema: Schema.Union<readonly [Schema.Struct<{
+    /** Agent that owns this Almanac schedule. */
+    readonly agentId: Schema.String;
+    /** Identifies the native Almanac schedule representation. */
+    readonly kind: Schema.Literal<"almanac">;
+    /** Retained Almanac row, including its instruction and lifecycle state. */
+    readonly schedule: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly sessionId: Schema.String;
+        readonly prompt: Schema.String;
+        readonly cron: Schema.NullOr<Schema.Struct<{
+            readonly expression: Schema.String;
+            readonly timeZone: Schema.String;
+        }>>;
+        readonly nextDueAt: Schema.Int;
+        readonly state: Schema.Literals<readonly ["active", "paused", "cancelled", "finished"]>;
+        readonly lastCommandId: Schema.NullOr<Schema.String>;
+        readonly lastError: Schema.NullOr<Schema.String>;
+        readonly attempt: Schema.Int;
+    }>;
+}>, Schema.Struct<{
+    /** Agent that owns this Session's Loop. */
+    readonly agentId: Schema.String;
+    /** Identifies the native Loop representation. */
+    readonly kind: Schema.Literal<"loop">;
+    /** Retained Loop row with the Session identity used to address its owner. */
+    readonly schedule: Schema.Struct<{
+        /** Session containing this exact Loop. */
+        readonly sessionId: Schema.String;
+        readonly loopId: Schema.String;
+        readonly origin: Schema.Literals<readonly ["human", "model"]>;
+        readonly expiresAt: Schema.NullOr<Schema.Int>;
+        readonly prompt: Schema.String;
+        readonly mode: Schema.Literals<readonly ["self_paced", "fixed_interval"]>;
+        readonly cron: Schema.NullOr<Schema.Struct<{
+            readonly expression: Schema.String;
+            readonly timeZone: Schema.String;
+        }>>;
+        readonly state: Schema.Literals<readonly ["active", "paused", "finished", "failed", "cancelled"]>;
+        readonly commandId: Schema.String;
+        readonly reason: Schema.NullOr<Schema.String>;
+        readonly nextDueAt: Schema.NullOr<Schema.Int>;
+        readonly lastError: Schema.NullOr<Schema.String>;
+        readonly consecutiveFailures: Schema.Int;
+    }>;
+}>]>;
+/** One Agent's retained schedule, including its native content. */
+export type AgentScheduleRow = typeof agentScheduleRowSchema.Type;
+/** Exact listed identity; a Loop target never selects its later replacement. */
+export declare const agentScheduleTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"almanac">;
+    agentId: z.ZodString;
+    scheduleId: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"loop">;
+    agentId: z.ZodString;
+    sessionId: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+    loopId: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+}, z.core.$strict>], "kind">;
+/** Identity to admit before acquiring the corresponding Agent owner. */
+export type AgentScheduleTarget = z.output<typeof agentScheduleTargetSchema>;
+/** A bounded content-bearing page; owner failures reject rather than look empty. */
+export declare const agentSchedulePageSchema: Schema.Struct<{
+    /** At most 64 retained rows, ordered Almanac first and then Loop. */
+    readonly items: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        /** Agent that owns this Almanac schedule. */
+        readonly agentId: Schema.String;
+        /** Identifies the native Almanac schedule representation. */
+        readonly kind: Schema.Literal<"almanac">;
+        /** Retained Almanac row, including its instruction and lifecycle state. */
+        readonly schedule: Schema.Struct<{
+            readonly id: Schema.String;
+            readonly sessionId: Schema.String;
+            readonly prompt: Schema.String;
+            readonly cron: Schema.NullOr<Schema.Struct<{
+                readonly expression: Schema.String;
+                readonly timeZone: Schema.String;
+            }>>;
+            readonly nextDueAt: Schema.Int;
+            readonly state: Schema.Literals<readonly ["active", "paused", "cancelled", "finished"]>;
+            readonly lastCommandId: Schema.NullOr<Schema.String>;
+            readonly lastError: Schema.NullOr<Schema.String>;
+            readonly attempt: Schema.Int;
+        }>;
+    }>, Schema.Struct<{
+        /** Agent that owns this Session's Loop. */
+        readonly agentId: Schema.String;
+        /** Identifies the native Loop representation. */
+        readonly kind: Schema.Literal<"loop">;
+        /** Retained Loop row with the Session identity used to address its owner. */
+        readonly schedule: Schema.Struct<{
+            /** Session containing this exact Loop. */
+            readonly sessionId: Schema.String;
+            readonly loopId: Schema.String;
+            readonly origin: Schema.Literals<readonly ["human", "model"]>;
+            readonly expiresAt: Schema.NullOr<Schema.Int>;
+            readonly prompt: Schema.String;
+            readonly mode: Schema.Literals<readonly ["self_paced", "fixed_interval"]>;
+            readonly cron: Schema.NullOr<Schema.Struct<{
+                readonly expression: Schema.String;
+                readonly timeZone: Schema.String;
+            }>>;
+            readonly state: Schema.Literals<readonly ["active", "paused", "finished", "failed", "cancelled"]>;
+            readonly commandId: Schema.String;
+            readonly reason: Schema.NullOr<Schema.String>;
+            readonly nextDueAt: Schema.NullOr<Schema.Int>;
+            readonly lastError: Schema.NullOr<Schema.String>;
+            readonly consecutiveFailures: Schema.Int;
+        }>;
+    }>]>>;
+    /** Exclusive continuation on a full page, or null when both kinds are exhausted. */
+    readonly next: Schema.NullOr<Schema.Struct<{
+        /** Agent whose traversal the next request must continue. */
+        readonly agentId: Schema.String;
+        /** Native owner to continue within that Agent. */
+        readonly kind: Schema.Literals<readonly ["almanac", "loop"]>;
+        /** Exclusive schedule ID or Session ID; absent starts the native kind. */
+        readonly after: Schema.optionalKey<Schema.String>;
+    }>>;
+}>;
+/** One Agent's page, with no directory fan-out or availability policy. */
+export type AgentSchedulePage = typeof agentSchedulePageSchema.Type;
+/** Manage-only result: exact target and native state, never prompt or history. */
+export declare const agentScheduleControlReceiptSchema: Schema.Union<readonly [Schema.Struct<{
+    /** Agent whose Almanac owner completed the transition. */
+    readonly agentId: Schema.String;
+    /** Identifies the controlled native Almanac schedule. */
+    readonly kind: Schema.Literal<"almanac">;
+    /** Identity of the schedule that was paused or cancelled. */
+    readonly scheduleId: Schema.String;
+    /** Native lifecycle state returned after the transition. */
+    readonly state: Schema.Literals<readonly ["active", "paused", "cancelled", "finished"]>;
+}>, Schema.Struct<{
+    /** Agent whose Loop owner completed the transition. */
+    readonly agentId: Schema.String;
+    /** Identifies the controlled native Loop. */
+    readonly kind: Schema.Literal<"loop">;
+    /** Session containing the controlled Loop. */
+    readonly sessionId: Schema.String;
+    /** Exact Loop identity checked by the native transition. */
+    readonly loopId: Schema.String;
+    /** Native lifecycle state returned after the transition. */
+    readonly state: Schema.Literals<readonly ["active", "paused", "finished", "failed", "cancelled"]>;
+}>]>;
+/** Content-free acknowledgement of the native owner's completed transition. */
+export type AgentScheduleControlReceipt = typeof agentScheduleControlReceiptSchema.Type;
+/**
+ * Read one already-admitted Agent, without scanning Sessions or draining pages.
+ * The caller owns Agent, home and resource authorization and the owner's lifetime.
+ */
+export declare function readAgentSchedulePage(agentId: string, owner: Pick<ShiitakeAgent, "extensions">, input?: z.input<typeof agentScheduleListInputSchema>): Promise<AgentSchedulePage>;
+/**
+ * Explicit content-returning control for callers admitted to both read and manage.
+ * In particular, private Local retains its native-row reply. The supplied owner
+ * must already be admitted for target.agentId; this helper grants no authority.
+ */
+export declare function controlAgentScheduleWithContent(owner: Pick<ShiitakeAgent, "extensions">, input: AgentScheduleTarget, action: "pause" | "delete"): Promise<AgentScheduleRow>;
+/** Control an already-admitted owner; manage-only callers receive no read content. */
+export declare function controlAgentSchedule(owner: Pick<ShiitakeAgent, "extensions">, target: AgentScheduleTarget, action: "pause" | "delete"): Promise<AgentScheduleControlReceipt>;

package/dist/schedules.js

@@ -0,0 +1,182 @@
+import { bindAgentExtension } from "@fungi.computer/shiitake/client";
+import * as Schema from "effect/Schema";
+import { z } from "zod";
+import { almanacContract, Schedule } from "./almanac/contract.js";
+import { Loop, loopContract } from "./loop/contract.js";
+const identity = z.string().min(1).max(256);
+/** Exclusive native key within one Agent's Almanac-then-Loop traversal. */
+export const agentScheduleCursorSchema = z
+    .strictObject({
+    /** Agent whose retained schedules this continuation traverses. */
+    agentId: identity,
+    /** Native owner to continue; Almanac precedes Loop in a fresh traversal. */
+    kind: z.union([z.literal("almanac"), z.literal("loop")]),
+    /** Exclusive Almanac schedule ID or Loop Session ID; absent starts the kind. */
+    after: identity.optional(),
+})
+    .refine(({ kind, after }) => Schema.is(kind === "almanac"
+    ? almanacContract.commands.list.input
+    : loopContract.commands.list.input)(after === undefined ? {} : { after }), { message: "Invalid schedule continuation key" });
+/** One bounded read; a full native page conservatively carries continuation. */
+export const agentScheduleListInputSchema = z.strictObject({
+    /** Native continuation from the previous page of this Agent's schedules. */
+    after: agentScheduleCursorSchema.optional(),
+    /** Shared row budget across both native kinds; defaults to and cannot exceed 64. */
+    limit: z.number().int().min(1).max(64).default(64),
+});
+/** Content-bearing read projection, decoded by the retained native contracts. */
+export const agentScheduleRowSchema = Schema.Union([
+    Schema.Struct({
+        /** Agent that owns this Almanac schedule. */
+        agentId: Schema.String,
+        /** Identifies the native Almanac schedule representation. */
+        kind: Schema.Literal("almanac"),
+        /** Retained Almanac row, including its instruction and lifecycle state. */
+        schedule: Schedule,
+    }),
+    Schema.Struct({
+        /** Agent that owns this Session's Loop. */
+        agentId: Schema.String,
+        /** Identifies the native Loop representation. */
+        kind: Schema.Literal("loop"),
+        /** Retained Loop row with the Session identity used to address its owner. */
+        schedule: Schema.Struct({
+            ...Loop.fields,
+            /** Session containing this exact Loop. */
+            sessionId: loopContract.commands.pauseLoop.input.fields.sessionId,
+        }),
+    }),
+]);
+/** Exact listed identity; a Loop target never selects its later replacement. */
+export const agentScheduleTargetSchema = z.discriminatedUnion("kind", [
+    z.strictObject({
+        /** Selects the native Almanac control. */
+        kind: z.literal("almanac"),
+        /** Agent whose owner the caller must admit before controlling this target. */
+        agentId: identity,
+        /** Exact native Almanac schedule to pause or cancel. */
+        scheduleId: identity.refine(Schema.is(Schedule.fields.id)),
+    }),
+    z.strictObject({
+        /** Selects an identified native Loop control. */
+        kind: z.literal("loop"),
+        /** Agent whose owner the caller must admit before controlling this target. */
+        agentId: identity,
+        /** Session containing the listed Loop. */
+        sessionId: identity.refine(Schema.is(loopContract.commands.pauseLoop.input.fields.sessionId)),
+        /** Exact listed Loop identity; a replacement must not be controlled instead. */
+        loopId: identity.refine(Schema.is(Loop.fields.loopId)),
+    }),
+]);
+/** A bounded content-bearing page; owner failures reject rather than look empty. */
+export const agentSchedulePageSchema = Schema.Struct({
+    /** At most 64 retained rows, ordered Almanac first and then Loop. */
+    items: Schema.Array(agentScheduleRowSchema).check(Schema.isMaxLength(64)),
+    /** Exclusive continuation on a full page, or null when both kinds are exhausted. */
+    next: Schema.NullOr(Schema.Struct({
+        /** Agent whose traversal the next request must continue. */
+        agentId: Schema.String,
+        /** Native owner to continue within that Agent. */
+        kind: Schema.Literals(["almanac", "loop"]),
+        /** Exclusive schedule ID or Session ID; absent starts the native kind. */
+        after: Schema.optionalKey(Schema.String),
+    })),
+});
+/** Manage-only result: exact target and native state, never prompt or history. */
+export const agentScheduleControlReceiptSchema = Schema.Union([
+    Schema.Struct({
+        /** Agent whose Almanac owner completed the transition. */
+        agentId: Schema.String,
+        /** Identifies the controlled native Almanac schedule. */
+        kind: Schema.Literal("almanac"),
+        /** Identity of the schedule that was paused or cancelled. */
+        scheduleId: Schedule.fields.id,
+        /** Native lifecycle state returned after the transition. */
+        state: Schedule.fields.state,
+    }),
+    Schema.Struct({
+        /** Agent whose Loop owner completed the transition. */
+        agentId: Schema.String,
+        /** Identifies the controlled native Loop. */
+        kind: Schema.Literal("loop"),
+        /** Session containing the controlled Loop. */
+        sessionId: loopContract.commands.pauseLoop.input.fields.sessionId,
+        /** Exact Loop identity checked by the native transition. */
+        loopId: Loop.fields.loopId,
+        /** Native lifecycle state returned after the transition. */
+        state: Loop.fields.state,
+    }),
+]);
+/**
+ * Read one already-admitted Agent, without scanning Sessions or draining pages.
+ * The caller owns Agent, home and resource authorization and the owner's lifetime.
+ */
+export async function readAgentSchedulePage(agentId, owner, input = {}) {
+    const { after, limit } = agentScheduleListInputSchema.parse(input);
+    if (after !== undefined && after.agentId !== agentId)
+        throw new Error("Schedule continuation belongs to another Agent");
+    const items = [];
+    if (after?.kind !== "loop") {
+        const nativeInput = after?.after === undefined ? { limit } : { limit, after: after.after };
+        const rows = await bindAgentExtension(owner, almanacContract).call("list", nativeInput);
+        for (const schedule of rows)
+            items.push({ agentId, kind: "almanac", schedule });
+        const last = rows.at(-1);
+        if (items.length === limit && last !== undefined)
+            return {
+                items,
+                next: { agentId, kind: "almanac", after: last.id },
+            };
+    }
+    const remaining = limit - items.length;
+    const cursor = after?.kind === "loop" ? after.after : undefined;
+    const nativeInput = cursor === undefined
+        ? { limit: remaining }
+        : { limit: remaining, after: cursor };
+    const rows = await bindAgentExtension(owner, loopContract).call("list", nativeInput);
+    for (const schedule of rows)
+        items.push({ agentId, kind: "loop", schedule });
+    const last = rows.at(-1);
+    return {
+        items,
+        next: items.length === limit && last !== undefined
+            ? { agentId, kind: "loop", after: last.sessionId }
+            : null,
+    };
+}
+/**
+ * Explicit content-returning control for callers admitted to both read and manage.
+ * In particular, private Local retains its native-row reply. The supplied owner
+ * must already be admitted for target.agentId; this helper grants no authority.
+ */
+export async function controlAgentScheduleWithContent(owner, input, action) {
+    const target = agentScheduleTargetSchema.parse(input);
+    if (target.kind === "almanac") {
+        const schedule = await bindAgentExtension(owner, almanacContract).call(action === "pause" ? "pause" : "cancel", { scheduleId: target.scheduleId });
+        return { agentId: target.agentId, kind: "almanac", schedule };
+    }
+    const loop = await bindAgentExtension(owner, loopContract).call(action === "pause" ? "pauseLoop" : "stopLoop", { sessionId: target.sessionId, loopId: target.loopId });
+    return {
+        agentId: target.agentId,
+        kind: "loop",
+        schedule: { ...loop, sessionId: target.sessionId },
+    };
+}
+/** Control an already-admitted owner; manage-only callers receive no read content. */
+export async function controlAgentSchedule(owner, target, action) {
+    const row = await controlAgentScheduleWithContent(owner, target, action);
+    return row.kind === "almanac"
+        ? {
+            agentId: row.agentId,
+            kind: "almanac",
+            scheduleId: row.schedule.id,
+            state: row.schedule.state,
+        }
+        : {
+            agentId: row.agentId,
+            kind: "loop",
+            sessionId: row.schedule.sessionId,
+            loopId: row.schedule.loopId,
+            state: row.schedule.state,
+        };
+}

package/dist/subagents/client.js

@@ -2,32 +2,64 @@ import { defineClientEntry, } from "@fungi.computer/shiitake/client-entry";
 import { subagentsContract, } from "./contract.js";
 const presentation = {
     working: { label: "working", tone: "running", status: "info" },
-    waiting: { label: "waiting on you", tone: "attention", status: "warning" },
+    waiting_on_agent: { label: "waiting", tone: "muted", status: "neutral" },
+    needs_you: { label: "needs you", tone: "attention", status: "warning" },
     idle: { label: "idle", tone: "settled", status: "success" },
     failed: { label: "failed", tone: "error", status: "error" },
     unavailable: { label: "unavailable", tone: "muted", status: "neutral" },
 };
+/** "waiting on Shiitake": the Agent a calm child waits on, never "you". */
+function label(agent) {
+    return agent.state === "waiting_on_agent"
+        ? `waiting on ${agent.waitingOn ?? "its parent"}`
+        : presentation[agent.state].label;
+}
 function row(agent) {
     const shown = presentation[agent.state];
     const base = {
         id: agent.agentId,
-        title: `${agent.name} · ${shown.label}`,
+        title: `${agent.name} · ${label(agent)}`,
         tone: shown.tone,
-        status: { label: shown.label, tone: shown.status },
+        status: { label: label(agent), tone: shown.status },
     };
-    const detailed = agent.attention === undefined ? base : { ...base, detail: agent.attention };
+    // The question itself, so a person can decide without opening the child.
+    const asked = agent.ask?.questions[0]?.question;
+    const text = asked ?? agent.attention;
+    const detailed = text === undefined ? base : { ...base, detail: text.slice(0, 200) };
     // An Agent created but never messaged has no conversation to open yet.
-    return agent.sessionId === null
-        ? { ...detailed, detail: agent.attention ?? "not messaged yet" }
-        : {
-            ...detailed,
-            open: {
-                params: [
-                    { key: "agent", value: agent.agentId },
-                    { key: "session", value: agent.sessionId },
-                ],
-            },
-        };
+    if (agent.sessionId === null)
+        return { ...detailed, detail: agent.attention ?? "not messaged yet" };
+    const opened = {
+        ...detailed,
+        open: {
+            params: [
+                { key: "agent", value: agent.agentId },
+                { key: "session", value: agent.sessionId },
+            ],
+        },
+    };
+    if (agent.ask === undefined)
+        return opened;
+    const answer = {
+        id: "answerChild",
+        label: "Answer",
+        input: {
+            agentId: agent.agentId,
+            sessionId: agent.sessionId,
+            askId: agent.ask.askId,
+        },
+    };
+    // A question offers the one Answer action, calm or not: a person may always
+    // answer, and the first answer wins. Only a question that needs the person
+    // takes over the composer.
+    return {
+        ...opened,
+        actions: [
+            agent.state === "needs_you"
+                ? { ...answer, awaiting: "question" }
+                : answer,
+        ],
+    };
 }
 /**
  * One summary row while the footer is collapsed: how
@@ -36,12 +68,24 @@ function row(agent) {
  */
 function summary(view) {
     const count = (state) => view.agents.filter((agent) => agent.state === state).length;
-    const counts = ["working", "waiting", "failed", "unavailable"]
-        .map((state) => [state, count(state)])
-        .filter(([, n]) => n > 0)
-        .map(([state, n]) => `${String(n)} ${presentation[state].label}`);
+    const calm = view.agents.filter((agent) => agent.state === "waiting_on_agent");
+    // Calm children name who they wait on; only needs-you children are amber.
+    const waiting = [
+        ...new Set(calm.map((agent) => agent.waitingOn ?? "its parent")),
+    ].map((name) => `${String(calm.filter((agent) => (agent.waitingOn ?? "its parent") === name).length)} waiting on ${name}`);
+    const counts = [
+        ...["working"]
+            .map((state) => [state, count(state)])
+            .filter(([, n]) => n > 0)
+            .map(([state, n]) => `${String(n)} ${presentation[state].label}`),
+        ...waiting,
+        ...["needs_you", "failed", "unavailable"]
+            .map((state) => [state, count(state)])
+            .filter(([, n]) => n > 0)
+            .map(([state, n]) => `${String(n)} ${presentation[state].label}`),
+    ];
     const total = view.agents.length + view.more;
-    const tone = count("waiting") > 0
+    const tone = count("needs_you") > 0
         ? "attention"
         : count("failed") > 0
             ? "error"