@fungi.computer/shiitake-extensions 0.3.0 → 0.4.0

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

@@ -1,9 +1,19 @@
 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. */
+type SendingDirectory = Omit<AgentControlDirectory, "open"> & Readonly<{
+    open: (agentId: string, signal: AbortSignal) => Promise<Readonly<{
+        agent: Readonly<{
+            session: (sessionId: string) => Pick<ShiitakeSession, "extension">;
+        }>;
+        release: () => 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 +24,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. */
@@ -25,3 +35,4 @@ export declare function oysterAgentExtensions(source: SubagentSource): Readonly<
     roster: readonly import("@fungi.computer/shiitake").RosteredExtensionV0[];
     grants: readonly import("@fungi.computer/shiitake").ExtensionGrantV0[];
 }>;
+export {};

package/dist/roster/conversation-agents.js

@@ -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,16 @@ 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);
+}
 /**
  * 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 +87,31 @@ 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 bindSessionExtension(opened.agent.session(sessionId), goalContract).call("set", {
+                                    objective: laneObjective(task.text, task.goal),
+                                    expectedRevision: null,
+                                    requestId: `lane-goal:${accepted.commandId}`,
+                                    // The send is the lane's first turn; never repeat it.
+                                    adoptCommandId: accepted.commandId,
+                                });
+                            }
+                            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/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"

package/dist/subagents/contract.d.ts

@@ -2,11 +2,12 @@ import * as Schema from "effect/Schema";
 /** The most Agents one conversation's footer lists; the rest are counted. */
 export declare const maximumSubagents = 16;
 /**
- * What the human sees for one ordinary created Agent. `waiting` is any open attention on
- * its conversation (a question or a tool approval); `unavailable` means its
- * status could not be read, and is never shown as idle.
+ * What the human sees for one ordinary created Agent. `waiting_on_agent` is an
+ * open question that waits on the Agent that sent the work, calm until it is
+ * escalated; `needs_you` is attention that waits on a person; `unavailable`
+ * means its status could not be read, and is never shown as idle.
  */
-export declare const SubagentState: Schema.Literals<readonly ["working", "waiting", "idle", "failed", "unavailable"]>;
+export declare const SubagentState: Schema.Literals<readonly ["working", "waiting_on_agent", "needs_you", "idle", "failed", "unavailable"]>;
 /** Display state of one created Agent's conversation. */
 export type SubagentState = typeof SubagentState.Type;
 /** A footer row for an ordinary Agent created by this Agent, never merely sent work. */
@@ -18,9 +19,27 @@ export declare const Subagent: Schema.Struct<{
     /** Its latest conversation; null when it has none. */
     readonly sessionId: Schema.NullOr<Schema.String>;
     /** Observed conversation state, including unreadable status. */
-    readonly state: Schema.Literals<readonly ["working", "waiting", "idle", "failed", "unavailable"]>;
-    /** The child's own summary of what waits on the human, when waiting. */
+    readonly state: Schema.Literals<readonly ["working", "waiting_on_agent", "needs_you", "idle", "failed", "unavailable"]>;
+    /** The child's own summary of what it waits on, when waiting. */
     readonly attention: Schema.optionalKey<Schema.String>;
+    /** Display name of the Agent a `waiting_on_agent` child waits on. */
+    readonly waitingOn: Schema.optionalKey<Schema.String>;
+    /** The question a waiting child asks, so a person can answer from here. */
+    readonly ask: Schema.optionalKey<Schema.Struct<{
+        /** Durable identity of the child's open Ask. */
+        readonly askId: Schema.String;
+        /** The decisions the child asks, so they can be answered from here. */
+        readonly questions: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly header: Schema.String;
+            readonly question: Schema.String;
+            readonly options: Schema.$Array<Schema.Struct<{
+                readonly label: Schema.String;
+                readonly description: Schema.String;
+            }>>;
+            readonly multiple: Schema.optionalKey<Schema.Boolean>;
+        }>>;
+    }>>;
 }>;
 /** Decoded footer row for a created Agent. */
 export type Subagent = typeof Subagent.Type;
@@ -39,9 +58,27 @@ export declare const SubagentsProjection: Schema.Struct<{
         /** Its latest conversation; null when it has none. */
         readonly sessionId: Schema.NullOr<Schema.String>;
         /** Observed conversation state, including unreadable status. */
-        readonly state: Schema.Literals<readonly ["working", "waiting", "idle", "failed", "unavailable"]>;
-        /** The child's own summary of what waits on the human, when waiting. */
+        readonly state: Schema.Literals<readonly ["working", "waiting_on_agent", "needs_you", "idle", "failed", "unavailable"]>;
+        /** The child's own summary of what it waits on, when waiting. */
         readonly attention: Schema.optionalKey<Schema.String>;
+        /** Display name of the Agent a `waiting_on_agent` child waits on. */
+        readonly waitingOn: Schema.optionalKey<Schema.String>;
+        /** The question a waiting child asks, so a person can answer from here. */
+        readonly ask: Schema.optionalKey<Schema.Struct<{
+            /** Durable identity of the child's open Ask. */
+            readonly askId: Schema.String;
+            /** The decisions the child asks, so they can be answered from here. */
+            readonly questions: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly header: Schema.String;
+                readonly question: Schema.String;
+                readonly options: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.String;
+                    readonly description: Schema.String;
+                }>>;
+                readonly multiple: Schema.optionalKey<Schema.Boolean>;
+            }>>;
+        }>>;
     }>>;
     /** Additional created Agents not included in the visible rows. */
     readonly more: Schema.Int;
@@ -50,6 +87,33 @@ export declare const SubagentsProjection: Schema.Struct<{
 }>;
 /** Decoded list and expansion state projected into the footer. */
 export type SubagentsProjection = typeof SubagentsProjection.Type;
+/**
+ * The question flow's own steps, each naming the child whose Ask they answer.
+ * The footer owns the conversation; the child's question owner commits it.
+ */
+export declare const AnswerChildInput: Schema.Union<Schema.Struct<{
+    readonly agentId: Schema.String;
+    readonly sessionId: Schema.String;
+    readonly answer: Schema.Struct<{
+        readonly selected: Schema.$Array<Schema.String>;
+        readonly text: Schema.optionalKey<Schema.String>;
+    }>;
+    readonly askId: Schema.String;
+    readonly requestId: Schema.String;
+    readonly index: Schema.Number;
+    readonly answers: Schema.$Record<Schema.String, Schema.Struct<{
+        readonly selected: Schema.$Array<Schema.String>;
+        readonly text: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly stage: Schema.Literal<"decision">;
+} | {
+    readonly agentId: Schema.String;
+    readonly sessionId: Schema.String;
+    readonly askId: Schema.String;
+} | {
+    readonly agentId: Schema.String;
+    readonly sessionId: Schema.String;
+}>[]>;
 /** Created-Agent footer control and its visible projection. */
 export declare const subagentsContract: {
     /** Stable extension identity. */
@@ -65,6 +129,37 @@ export declare const subagentsContract: {
             /** Return the server-owned human control step. */
             output: Schema.declare<import("@fungi.computer/whistle/catalog").WhistleCatalogStepV1, import("@fungi.computer/whistle/catalog").WhistleCatalogStepV1>;
         };
+        /** Answer a question an escalated sub-agent asks, from this conversation. */
+        answerChild: {
+            /** The Session owns its footer. */
+            scope: "session";
+            /** The next step of the child's answer conversation. */
+            input: Schema.Union<Schema.Struct<{
+                readonly agentId: Schema.String;
+                readonly sessionId: Schema.String;
+                readonly answer: Schema.Struct<{
+                    readonly selected: Schema.$Array<Schema.String>;
+                    readonly text: Schema.optionalKey<Schema.String>;
+                }>;
+                readonly askId: Schema.String;
+                readonly requestId: Schema.String;
+                readonly index: Schema.Number;
+                readonly answers: Schema.$Record<Schema.String, Schema.Struct<{
+                    readonly selected: Schema.$Array<Schema.String>;
+                    readonly text: Schema.optionalKey<Schema.String>;
+                }>>;
+                readonly stage: Schema.Literal<"decision">;
+            } | {
+                readonly agentId: Schema.String;
+                readonly sessionId: Schema.String;
+                readonly askId: Schema.String;
+            } | {
+                readonly agentId: Schema.String;
+                readonly sessionId: Schema.String;
+            }>[]>;
+            /** Return the next human conversation step. */
+            output: Schema.declare<import("@fungi.computer/whistle/catalog").WhistleCatalogStepV1, import("@fungi.computer/whistle/catalog").WhistleCatalogStepV1>;
+        };
     };
     /** Footer rows and expansion state. */
     readonly projection: {
@@ -79,9 +174,27 @@ export declare const subagentsContract: {
                 /** Its latest conversation; null when it has none. */
                 readonly sessionId: Schema.NullOr<Schema.String>;
                 /** Observed conversation state, including unreadable status. */
-                readonly state: Schema.Literals<readonly ["working", "waiting", "idle", "failed", "unavailable"]>;
-                /** The child's own summary of what waits on the human, when waiting. */
+                readonly state: Schema.Literals<readonly ["working", "waiting_on_agent", "needs_you", "idle", "failed", "unavailable"]>;
+                /** The child's own summary of what it waits on, when waiting. */
                 readonly attention: Schema.optionalKey<Schema.String>;
+                /** Display name of the Agent a `waiting_on_agent` child waits on. */
+                readonly waitingOn: Schema.optionalKey<Schema.String>;
+                /** The question a waiting child asks, so a person can answer from here. */
+                readonly ask: Schema.optionalKey<Schema.Struct<{
+                    /** Durable identity of the child's open Ask. */
+                    readonly askId: Schema.String;
+                    /** The decisions the child asks, so they can be answered from here. */
+                    readonly questions: Schema.$Array<Schema.Struct<{
+                        readonly id: Schema.String;
+                        readonly header: Schema.String;
+                        readonly question: Schema.String;
+                        readonly options: Schema.$Array<Schema.Struct<{
+                            readonly label: Schema.String;
+                            readonly description: Schema.String;
+                        }>>;
+                        readonly multiple: Schema.optionalKey<Schema.Boolean>;
+                    }>>;
+                }>>;
             }>>;
             /** Additional created Agents not included in the visible rows. */
             readonly more: Schema.Int;

package/dist/subagents/contract.js

@@ -1,17 +1,20 @@
 import { ExtensionId, } from "@fungi.computer/shiitake/extensions";
 import * as Schema from "effect/Schema";
 import { CatalogStep } from "../internal/catalog.js";
+import { AnswerFlowInput, Questions } from "../question/contract.js";
 const identity = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256));
 /** The most Agents one conversation's footer lists; the rest are counted. */
 export const maximumSubagents = 16;
 /**
- * What the human sees for one ordinary created Agent. `waiting` is any open attention on
- * its conversation (a question or a tool approval); `unavailable` means its
- * status could not be read, and is never shown as idle.
+ * What the human sees for one ordinary created Agent. `waiting_on_agent` is an
+ * open question that waits on the Agent that sent the work, calm until it is
+ * escalated; `needs_you` is attention that waits on a person; `unavailable`
+ * means its status could not be read, and is never shown as idle.
  */
 export const SubagentState = Schema.Literals([
     "working",
-    "waiting",
+    "waiting_on_agent",
+    "needs_you",
     "idle",
     "failed",
     "unavailable",
@@ -26,8 +29,17 @@ export const Subagent = Schema.Struct({
     sessionId: Schema.NullOr(identity),
     /** Observed conversation state, including unreadable status. */
     state: SubagentState,
-    /** The child's own summary of what waits on the human, when waiting. */
+    /** The child's own summary of what it waits on, when waiting. */
     attention: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(200))),
+    /** Display name of the Agent a `waiting_on_agent` child waits on. */
+    waitingOn: Schema.optionalKey(identity),
+    /** The question a waiting child asks, so a person can answer from here. */
+    ask: Schema.optionalKey(Schema.Struct({
+        /** Durable identity of the child's open Ask. */
+        askId: identity,
+        /** The decisions the child asks, so they can be answered from here. */
+        questions: Questions,
+    })),
 });
 /**
  * This Agent's created Agents and how many are not listed.
@@ -42,6 +54,18 @@ export const SubagentsProjection = Schema.Struct({
     /** Whether individual rows are expanded instead of summarized. */
     expanded: Schema.Boolean,
 });
+/** One child, as an answer step names it beside the draft it advances. */
+const child = {
+    /** Identity of the child Agent whose Ask is being answered. */
+    agentId: identity,
+    /** The child's conversation that holds the Ask. */
+    sessionId: identity,
+};
+/**
+ * The question flow's own steps, each naming the child whose Ask they answer.
+ * The footer owns the conversation; the child's question owner commits it.
+ */
+export const AnswerChildInput = Schema.Union(AnswerFlowInput.members.map((member) => Schema.Struct({ ...member.fields, ...child })));
 /** The human `/agents` command: a bare call expands or collapses the footer rows. */
 const commands = {
     /** Toggle the created-Agent footer between expanded and summarized views. */
@@ -53,6 +77,15 @@ const commands = {
         /** Return the server-owned human control step. */
         output: CatalogStep,
     },
+    /** Answer a question an escalated sub-agent asks, from this conversation. */
+    answerChild: {
+        /** The Session owns its footer. */
+        scope: "session",
+        /** The next step of the child's answer conversation. */
+        input: AnswerChildInput,
+        /** Return the next human conversation step. */
+        output: CatalogStep,
+    },
 };
 /** Created-Agent footer control and its visible projection. */
 export const subagentsContract = {

package/dist/subagents/host.d.ts

@@ -14,7 +14,7 @@ export type SubagentAgent = Readonly<{
     /** Read the child's owner-ordered conversation summaries. */
     listSessions: ShiitakeAgent["listSessions"];
     /** Open the read-only view of a selected child conversation. */
-    session: (sessionId: string) => Pick<ShiitakeSession, "read" | "readSettlement">;
+    session: (sessionId: string) => Pick<ShiitakeSession, "read" | "readSettlement" | "extension">;
 }>;
 /**
  * The host's read-only facts. `read` returns ordinary created Agents,
@@ -44,10 +44,8 @@ export type SubagentSource = Readonly<{
 export type SubagentTiming = Readonly<{
     /** A watcher's read refreshes rows at least this old. */
     refreshMs: number;
-    /** While a row is working or waiting, rows refresh this often. */
+    /** While a live view watches a working or waiting row, refresh this often. */
     pollMs: number;
-    /** Polling stops once no watcher has read the Session this long. */
-    interestMs: number;
 }>;
 /** Host admission for the read-only created-Agent footer and human toggle. */
 export declare const subagentsGrant: ExtensionGrantV0;