@fungi.computer/shiitake-extensions 0.1.1 → 0.3.0

package/README.md

@@ -65,16 +65,16 @@ helper borrows the Agent. Its owner closes it when the host's lifetime ends.
 
 ## Core concepts
 
-| 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 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, and `/agents` collapses the rows to one summary row and expands them again. It owns no relationship and no durable state.                                                                                                                      |
+| 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 live or paused objective per Session. The model creates, reads and completes it through `goal.*` tools, from any later turn of its Session; humans set, pause, resume or clear it. Esc, failed work, a block or three tool-less continuations pause it; a tool-less goal turn while a sub-agent command is live waits instead. 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, 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
@@ -90,14 +90,21 @@ 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; 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 pauses and resumes like any paused goal. Each run's goal tools are fenced
+by the goal revision that run saw, so a later follow-up command (for example a
+parent's message to a sub-agent) can complete, block, clear or resume a goal
+that paused on its own; a goal a person paused or stopped accepts only
+completion from the model, and only a person clears a live goal. When a
+tool-less goal turn ends while a recorded sub-agent command is live, the goal
+raises `goal-waiting` attention and rechecks on a timer instead of counting a
+stall; it continues once the child settles or replies. 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`,

package/dist/goal/contract.d.ts

@@ -44,9 +44,12 @@ export declare const EndedGoal: Schema.Struct<{
     readonly sequence: Schema.Int;
     /** Objective that finished or was cleared. */
     readonly objective: Schema.String;
-    /** Whether the model achieved the goal or a person cleared it. */
+    /** Whether the model achieved the goal or it was cleared. */
     readonly outcome: Schema.Literals<readonly ["achieved", "cleared"]>;
-    /** The model's evidence for an achieved goal; null when cleared. */
+    /**
+     * The model's evidence for an achieved goal, or its explanation for
+     * clearing its own paused goal; null when a person cleared it.
+     */
     readonly reason: Schema.NullOr<Schema.String>;
     /** Completion time in epoch milliseconds. */
     readonly endedAt: Schema.Int;
@@ -74,7 +77,9 @@ export declare const GoalCommandInput: Schema.Union<readonly [Schema.Struct<{
     readonly confirmed: Schema.optional<Schema.Boolean>;
 }>, Schema.Struct<{
     /** Select an existing-goal control. */
-    readonly action: Schema.Literals<readonly ["pause", "resume", "replace", "clear"]>;
+    readonly action: Schema.Literals<readonly ["pause", "resume", "replace", "clear", "clear-ask"]>;
+    /** The human's answer to "clear this goal?"; absent for a typed clear. */
+    readonly confirmed: Schema.optional<Schema.Boolean>;
 }>, Schema.Struct<{}>]>;
 /** Goal's contract: Session-scope human controls and one projection slot. */
 export declare const GoalProjection: Schema.Struct<{
@@ -102,9 +107,12 @@ export declare const GoalProjection: Schema.Struct<{
         readonly sequence: Schema.Int;
         /** Objective that finished or was cleared. */
         readonly objective: Schema.String;
-        /** Whether the model achieved the goal or a person cleared it. */
+        /** Whether the model achieved the goal or it was cleared. */
         readonly outcome: Schema.Literals<readonly ["achieved", "cleared"]>;
-        /** The model's evidence for an achieved goal; null when cleared. */
+        /**
+         * The model's evidence for an achieved goal, or its explanation for
+         * clearing its own paused goal; null when a person cleared it.
+         */
         readonly reason: Schema.NullOr<Schema.String>;
         /** Completion time in epoch milliseconds. */
         readonly endedAt: Schema.Int;
@@ -138,7 +146,9 @@ export declare const goalContract: {
                 readonly confirmed: Schema.optional<Schema.Boolean>;
             }>, Schema.Struct<{
                 /** Select an existing-goal control. */
-                readonly action: Schema.Literals<readonly ["pause", "resume", "replace", "clear"]>;
+                readonly action: Schema.Literals<readonly ["pause", "resume", "replace", "clear", "clear-ask"]>;
+                /** The human's answer to "clear this goal?"; absent for a typed clear. */
+                readonly confirmed: Schema.optional<Schema.Boolean>;
             }>, Schema.Struct<{}>]>;
             /** Return the server-owned conversation step. */
             readonly output: Schema.declare<import("@fungi.computer/whistle/catalog").WhistleCatalogStepV1, import("@fungi.computer/whistle/catalog").WhistleCatalogStepV1>;
@@ -273,9 +283,12 @@ export declare const goalContract: {
                 readonly sequence: Schema.Int;
                 /** Objective that finished or was cleared. */
                 readonly objective: Schema.String;
-                /** Whether the model achieved the goal or a person cleared it. */
+                /** Whether the model achieved the goal or it was cleared. */
                 readonly outcome: Schema.Literals<readonly ["achieved", "cleared"]>;
-                /** The model's evidence for an achieved goal; null when cleared. */
+                /**
+                 * The model's evidence for an achieved goal, or its explanation for
+                 * clearing its own paused goal; null when a person cleared it.
+                 */
                 readonly reason: Schema.NullOr<Schema.String>;
                 /** Completion time in epoch milliseconds. */
                 readonly endedAt: Schema.Int;

package/dist/goal/contract.js

@@ -46,9 +46,12 @@ export const EndedGoal = Schema.Struct({
     sequence: Schema.Int.check(Schema.isGreaterThan(0)),
     /** Objective that finished or was cleared. */
     objective: Objective,
-    /** Whether the model achieved the goal or a person cleared it. */
+    /** Whether the model achieved the goal or it was cleared. */
     outcome: Schema.Literals(["achieved", "cleared"]),
-    /** The model's evidence for an achieved goal; null when cleared. */
+    /**
+     * The model's evidence for an achieved goal, or its explanation for
+     * clearing its own paused goal; null when a person cleared it.
+     */
     reason: Schema.NullOr(GoalReason),
     /** Completion time in epoch milliseconds. */
     endedAt: EpochMillis,
@@ -76,7 +79,15 @@ export const GoalCommandInput = Schema.Union([
     }),
     Schema.Struct({
         /** Select an existing-goal control. */
-        action: Schema.Literals(["pause", "resume", "replace", "clear"]),
+        action: Schema.Literals([
+            "pause",
+            "resume",
+            "replace",
+            "clear",
+            "clear-ask",
+        ]),
+        /** The human's answer to "clear this goal?"; absent for a typed clear. */
+        confirmed: Schema.optional(Schema.Boolean),
     }),
     Schema.Struct({}),
 ]);

package/dist/goal/host.d.ts

@@ -1,5 +1,8 @@
 import { type RosteredExtensionV0 } from "@fungi.computer/shiitake/extensions";
+import type { SubagentSource } from "../subagents/host.js";
 /** The commands this extension advertises to every client. */
 export declare const goalCatalog: import("@fungi.computer/shiitake/extensions").Json;
-/** Botanical's Session goal, driven only by settled runs. */
+/** Botanical's Session goal; hosts with created-Agent facts include them in progress. */
+export declare function goalExtensionFor(subagents?: SubagentSource): RosteredExtensionV0;
+/** Ordinary roster when no created-Agent directory is available. */
 export declare const goalExtension: RosteredExtensionV0;

package/dist/goal/host.js

@@ -9,16 +9,19 @@ import * as Schema from "effect/Schema";
 import { z } from "zod";
 import { ask, catalog, declined, done, freshRequestId, } from "../internal/catalog.js";
 import { EndedGoal, endedGoalLimit, Goal, GoalCommandInput, goalContract, GoalReason, Objective, } from "./contract.js";
+import { clearConfirmation, goalMenuPrompt, replaceConfirmation, } from "./prompts.js";
 /** The rules the model follows; the describe page and an active goal's prompt share them. */
-const rules = "You may start a goal yourself when none is current. Before marking complete audit every requirement against evidence; complete only after actual achievement. Block only after the same external impasse for three consecutive goal turns; a blocked goal pauses until a person resumes it. Human pause/resume/clear remain human controls. Use plan.update_plan for multi-step work when available.";
+const rules = "You may start a goal yourself when none is current. Before marking complete audit every requirement against evidence; complete only after actual achievement. Block only after the same external impasse for three consecutive goal turns; a blocked goal stays paused until it is resumed. You may complete, block, clear or resume a goal that paused on its own (stalled, blocked or failed work); a goal a person paused or stopped you may only complete, and only a person clears a live goal. Human pause/resume/clear remain human controls. Use plan.update_plan for multi-step work when available.";
 /** Hashed prose and policy: every constant goal reads comes from here. */
 const config = {
     continuation: "Continue working toward the current goal described in the goal section. Find goal.get_goal and goal.update_goal with forage.search({query:'goal'}) and forage.describe. Audit every requirement against evidence before goal.update_goal({status:'complete', reason}). If the same external blocker persists for three goal turns, report blocked with a reason. Check for progress rather than repeating yourself.",
-    moduleDescription: "Session goal tools: create_goal({objective}), get_goal({}), update_goal({status:'complete'|'blocked', reason}). " +
+    moduleDescription: "Session goal tools: create_goal({objective}), get_goal({}), update_goal({status:'complete'|'blocked'|'clear'|'resume', reason}). " +
         rules,
     createDescription: "Create a Session goal, including autonomously. Fails while a goal is active or paused; a finished goal is history.",
     getDescription: "Read the current goal. A requested terminal state remains provisional until successful settlement.",
-    updateDescription: "Request complete only after actual achievement, or blocked only after the same external impasse for three consecutive goal turns; settlement commits the request. Complete ends the goal; blocked pauses it for a person.",
+    updateDescription: "Request complete only after actual achievement, or blocked only after the same external impasse for three consecutive goal turns; both also work on a paused goal, and settlement commits the request. Complete ends the goal; blocked pauses it for a person. clear abandons a paused goal with your reason. resume reactivates a paused goal now. A goal a person paused or stopped accepts only complete.",
+    waitCheckMs: 60_000,
+    waitingSummary: "Waiting on sub-agent",
     promptLimit: 1_024,
     stallTurns: 3,
     stallReason: "Stalled: no progress for 3 turns",
@@ -54,7 +57,7 @@ const GoalRow = Schema.Struct({
     sessionId: Schema.String,
     /** A model-requested terminal, committed only by its run's success. */
     pending: Schema.NullOr(Schema.Struct({
-        state: Schema.Literals(["complete", "blocked"]),
+        state: Schema.Literals(["complete", "blocked", "cleared"]),
         reason: GoalReason,
     })),
     stalledTurns: Schema.Int,
@@ -90,6 +93,7 @@ function committed(row) {
 function commitGoal(ctx, row) {
     return Effect.gen(function* () {
         yield* ctx.state.goals.put(row);
+        yield* ctx.attention.clear(row.sessionId, "waiting-goal");
         if (row.state === "paused" &&
             (row.pauseCause?.kind === "blocked" || row.pauseCause?.kind === "stalled"))
             yield* ctx.attention
@@ -150,6 +154,7 @@ function finishGoal(ctx, goal, outcome, reason) {
         });
         yield* ctx.state.goals.remove(goal.sessionId);
         yield* ctx.attention.clear(goal.sessionId, "paused-goal");
+        yield* ctx.attention.clear(goal.sessionId, "waiting-goal");
     });
 }
 /** Pause or reactivate the current goal without touching admitted work. */
@@ -197,7 +202,7 @@ function continueIfIdle(ctx, goal, requestId) {
  * settles here like any other, so the goal keeps going. An achieved goal
  * finishes and leaves the current slot.
  */
-function settle(ctx, run) {
+function settle(ctx, run, subagents) {
     return Effect.gen(function* () {
         const found = yield* ctx.state.goals.get(run.sessionId);
         if (Option.isNone(found))
@@ -220,6 +225,9 @@ function settle(ctx, run) {
             yield* commitGoal(ctx, paused(goal, "no-terminal", ctx.config.noTerminalReason));
             return yield* ctx.observe(run.sessionId);
         }
+        const waitingForChild = run.toolCalls === 0 &&
+            subagents?.hasLiveChildCommand(run.sessionId) === true &&
+            run.origin?.extensionId === goalContract.id;
         const tracked = {
             ...goal,
             trackedWorkId: run.workId,
@@ -228,16 +236,34 @@ function settle(ctx, run) {
                 ? run.toolCalls === 0
                     ? goal.stalledTurns + 1
                     : 0
-                : goal.stalledTurns,
+                : 0,
         };
         const pending = goal.trackedWorkId === run.workId ? goal.pending : null;
         if (pending?.state === "complete")
             yield* finishGoal(ctx, tracked, "achieved", pending.reason);
+        else if (pending?.state === "cleared")
+            yield* finishGoal(ctx, tracked, "cleared", pending.reason);
         else if (pending?.state === "blocked")
             yield* commitGoal(ctx, paused(tracked, "blocked", pending.reason));
         else if (goal.state === "active" &&
+            !waitingForChild &&
             tracked.stalledTurns >= ctx.config.stallTurns)
             yield* commitGoal(ctx, paused(tracked, "stalled", ctx.config.stallReason));
+        else if (goal.state === "active" && waitingForChild) {
+            // A tool-free goal turn while a child command is live is waiting, not
+            // stalling: show it, and recheck on a timer so the goal resumes when the
+            // child settles even if no reply mail wakes this Session.
+            yield* commitGoal(ctx, tracked);
+            const now = yield* Clock.currentTimeMillis;
+            yield* ctx.attention.set(run.sessionId, {
+                id: "waiting-goal",
+                kind: "goal-waiting",
+                inbox: false,
+                summary: `${ctx.config.waitingSummary}: ${tracked.objective}`.slice(0, 200),
+                since: now,
+            });
+            yield* ctx.timers.set(waitTimerKey(run.sessionId), now + ctx.config.waitCheckMs);
+        }
         else if (goal.state === "active")
             yield* commitGoal(ctx, yield* continueIfIdle(ctx, tracked, `goal-continue:${run.workId}`));
         else
@@ -245,6 +271,29 @@ function settle(ctx, run) {
         yield* ctx.observe(run.sessionId);
     });
 }
+const waitTimerPrefix = "waiting:";
+function waitTimerKey(sessionId) {
+    return `${waitTimerPrefix}${sessionId}`;
+}
+/**
+ * Recheck a goal that is waiting on a child command: keep waiting while the
+ * child is live, otherwise admit the next goal turn (an idle-only, replayed
+ * admission, so a Session that already moved on is unaffected).
+ */
+function recheckWaiting(ctx, timer, subagents) {
+    return Effect.gen(function* () {
+        if (!timer.key.startsWith(waitTimerPrefix))
+            return;
+        const sessionId = timer.key.slice(waitTimerPrefix.length);
+        const found = yield* ctx.state.goals.get(sessionId);
+        if (Option.isNone(found) || found.value.state !== "active")
+            return;
+        if (subagents?.hasLiveChildCommand(sessionId) === true)
+            return yield* ctx.timers.set(timer.key, timer.firedAt + ctx.config.waitCheckMs);
+        yield* commitGoal(ctx, yield* continueIfIdle(ctx, found.value, `goal-wait:${found.value.trackedWorkId}`));
+        yield* ctx.observe(sessionId);
+    });
+}
 /** Run one tool transaction and preserve its owner-admitted diagnostic. */
 function toolCall(ctx, operation, body) {
     return Effect.runPromiseExit(ctx.transact(body)).then((exit) => {
@@ -267,9 +316,24 @@ function toolCall(ctx, operation, body) {
 }
 // Mycelium's maintained operation interface takes Zod for model-tool I/O.
 const toolObjective = z.string().min(1).max(4_000);
-const toolState = z.enum(["active", "paused", "complete", "blocked"]);
-/** The model-facing goal tools for one run, guarded by that run's work id. */
-function goalModule(ctx, sessionId, workId) {
+const toolState = z.enum([
+    "active",
+    "paused",
+    "complete",
+    "blocked",
+    "cleared",
+]);
+/** The model-facing goal tools for one run, fenced by the goal it saw. */
+function goalModule(ctx, sessionId, workId, initialRevision) {
+    const currentGoal = Effect.gen(function* () {
+        const found = yield* ctx.state.goals.get(sessionId);
+        if (Option.isNone(found))
+            return yield* Effect.fail(conflict("No Session goal"));
+        if (found.value.revision !== initialRevision &&
+            found.value.revision !== `run:${workId}`)
+            return yield* Effect.fail(conflict("Session goal work guard is stale"));
+        return found.value;
+    });
     return Mycelium.module({
         id: "botanical.session-goal",
         name: "goal",
@@ -329,35 +393,68 @@ function goalModule(ctx, sessionId, workId) {
                 replay: "unsafe",
                 description: ctx.config.updateDescription,
                 input: z.strictObject({
-                    status: z.enum(["complete", "blocked"]),
+                    status: z.enum(["complete", "blocked", "clear", "resume"]),
                     reason: z.string().min(1).max(1_000),
                 }),
                 output: z.strictObject({
                     objective: toolObjective,
-                    state: z.enum(["complete", "blocked"]),
+                    state: z.enum(["active", "complete", "blocked", "cleared"]),
                     reason: z.string(),
                 }),
                 execute: ({ status, reason }) => toolCall(ctx, "update_goal", Effect.gen(function* () {
                     const decoded = yield* Schema.decodeUnknownEffect(GoalReason)(reason).pipe(Effect.mapError(() => conflict("Goal reason is invalid")));
-                    const found = yield* ctx.state.goals.get(sessionId);
-                    if (Option.isNone(found) ||
-                        found.value.trackedWorkId !== workId ||
-                        found.value.state !== "active")
-                        return yield* Effect.fail(conflict("Session goal work guard is stale"));
+                    const goal = yield* currentGoal;
+                    // A person's pause or stop is theirs: the model may only finish it.
+                    if (status !== "complete" && heldByPerson(goal))
+                        return yield* Effect.fail(conflict("A person paused or stopped this goal; only complete is available to you"));
+                    if (status === "resume") {
+                        const resumed = yield* modelResume(goal, workId);
+                        yield* commitGoal(ctx, resumed);
+                        yield* ctx.observe(sessionId);
+                        return {
+                            objective: goal.objective,
+                            state: "active",
+                            reason: decoded,
+                        };
+                    }
+                    // Only a person discards a live goal; the model may clear a paused one.
+                    if (status === "clear" && goal.state !== "paused")
+                        return yield* Effect.fail(conflict("Only a paused Session goal can be cleared"));
+                    const state = status === "clear" ? "cleared" : status;
                     yield* commitGoal(ctx, {
-                        ...found.value,
-                        pending: { state: status, reason: decoded },
+                        ...goal,
+                        // This run's settlement commits the provisional terminal.
+                        trackedWorkId: workId,
+                        pending: { state, reason: decoded },
                     });
-                    return {
-                        objective: found.value.objective,
-                        state: status,
-                        reason: decoded,
-                    };
+                    return { objective: goal.objective, state, reason: decoded };
                 })),
             }),
         },
     });
 }
+/** A person's pause or Esc; only a person resumes, blocks or clears it. */
+function heldByPerson(goal) {
+    return (goal.state === "paused" &&
+        (goal.pauseCause?.kind === "person" ||
+            goal.pauseCause?.kind === "cancelled"));
+}
+/**
+ * The model resumes its own paused goal. The resuming run becomes the
+ * tracked work, so its settlement admits the next goal turn.
+ */
+function modelResume(goal, workId) {
+    if (goal.state !== "paused")
+        return Effect.fail(conflict("Session goal is not paused"));
+    return Effect.succeed({
+        ...goal,
+        state: "active",
+        pauseCause: null,
+        pending: null,
+        stalledTurns: 0,
+        trackedWorkId: workId,
+    });
+}
 function pauseGoal(ctx, sessionId) {
     return changeActivity(ctx, sessionId, "paused").pipe(Effect.map(committed));
 }
@@ -420,6 +517,7 @@ function setGoal(ctx, sessionId, input) {
         return { goal: committed(row), accepted };
     });
 }
+/** The one-line state the model prompt and attention summaries carry. */
 function goalLine(goal) {
     if (goal.state === "active")
         return `Pursuing goal: ${goal.objective}`;
@@ -453,21 +551,15 @@ function humanGoal(ctx, sessionId, input) {
         if (!("action" in input)) {
             if (current === undefined)
                 return ask(objectivePrompt, { action: "set", requestId: yield* freshRequestId }, "objective");
-            const goal = committed(current);
-            return ask({
-                type: "choice",
-                message: goalLine(goal),
-                options: [
-                    goal.state === "active"
-                        ? { value: "pause", label: "Pause goal" }
-                        : { value: "resume", label: "Resume goal" },
-                    { value: "clear", label: "Clear goal" },
-                    { value: "replace", label: "Replace goal" },
-                ],
-            }, {}, "action");
+            return ask(goalMenuPrompt(committed(current), yield* Clock.currentTimeMillis), {}, "action");
         }
         switch (input.action) {
+            case "clear-ask":
+                // The menu's Clear: Keep is the focused answer to this destructive step.
+                return ask(clearConfirmation, { action: "clear" }, "confirmed");
             case "clear":
+                if (input.confirmed === false)
+                    return declined({ type: "info", message: "Kept the goal." });
                 // The chat's ending line confirms a clear; only an empty one says so.
                 return (yield* clearGoal(ctx, sessionId))
                     ? { type: "done" }
@@ -483,7 +575,6 @@ function humanGoal(ctx, sessionId, input) {
                     action: "set",
                     requestId: yield* freshRequestId,
                     expectedRevision: current?.revision ?? null,
-                    confirmed: true,
                 }, "objective");
             case "set": {
                 const retried = current?.revisionRequestId === input.requestId;
@@ -492,12 +583,7 @@ function humanGoal(ctx, sessionId, input) {
                 if (replacing && input.confirmed === false)
                     return declined({ type: "info", message: "Kept the current goal." });
                 if (replacing && input.confirmed !== true)
-                    return ask({
-                        type: "confirmation",
-                        message: `Replace the ${current.state === "active" ? "live" : "paused"} goal?\nCurrent: ${current.objective}\nNew: ${input.objective}`,
-                        confirmLabel: "Replace and start",
-                        cancelLabel: "Keep current goal",
-                    }, {
+                    return ask(replaceConfirmation(committed(current), input.objective), {
                         action: "set",
                         objective: input.objective,
                         requestId: input.requestId,
@@ -556,69 +642,80 @@ export const goalCatalog = catalog([
         },
     },
 ]);
-/** Botanical's Session goal, driven only by settled runs. */
-export const goalExtension = defineExtension({
-    id: goalContract.id,
-    version: "7.0.0",
-})
-    .config(config)
-    // A command anchor cannot be converted into a historical Session position.
-    // Old preview state must be republished separately, never guessed here.
-    .state({ version: 7, migrations: {}, collections })
-    .define({
-    attention: true,
-    prompt: (ctx, { sessionId, origin }) => Effect.gen(function* () {
-        const goal = Option.getOrNull(yield* ctx.state.goals.get(sessionId));
-        const text = goal === null
-            ? ctx.config.idle
-            : (goal.state === "active" ? ctx.config.guide : ctx.config.idle) +
-                "\n" +
-                goalLine(committed(goal));
-        return [
-            {
-                name: "goal",
-                text: boundedPrompt(text, ctx.config.promptLimit),
+/** Botanical's Session goal; hosts with created-Agent facts include them in progress. */
+export function goalExtensionFor(subagents) {
+    return (defineExtension({
+        id: goalContract.id,
+        version: "7.0.0",
+    })
+        .config(config)
+        // A command anchor cannot be converted into a historical Session position.
+        // Old preview state must be republished separately, never guessed here.
+        .state({ version: 7, migrations: {}, collections })
+        .define({
+        attention: true,
+        prompt: (ctx, { sessionId, origin }) => Effect.gen(function* () {
+            const goal = Option.getOrNull(yield* ctx.state.goals.get(sessionId));
+            const text = goal === null
+                ? ctx.config.idle
+                : (goal.state === "active"
+                    ? ctx.config.guide
+                    : ctx.config.idle) +
+                    "\n" +
+                    goalLine(committed(goal));
+            return [
+                {
+                    name: "goal",
+                    text: boundedPrompt(text, ctx.config.promptLimit),
+                },
+                ...(goal?.state === "active" &&
+                    origin?.extensionId === goalContract.id &&
+                    origin.correlation !== null
+                    ? [
+                        {
+                            name: "goal-continuation",
+                            text: boundedPrompt(ctx.config.continuation, ctx.config.promptLimit),
+                        },
+                    ]
+                    : []),
+            ];
+        }),
+        catalog: goalCatalog,
+        projection: {
+            schema: goalContract.projection.schema,
+            read: (ctx, sessionId) => {
+                const goal = Option.getOrUndefined(ctx.state.goals.peek(sessionId));
+                const endings = Option.getOrUndefined(ctx.state.endings.peek(sessionId));
+                if (goal === undefined && endings === undefined)
+                    return Option.none();
+                const ended = endings?.ended ?? [];
+                return Option.some({
+                    goal: goal === undefined ? null : committed(goal),
+                    ended,
+                    omitted: (endings?.total ?? 0) - ended.length,
+                });
             },
-            ...(goal?.state === "active" &&
-                origin?.extensionId === goalContract.id &&
-                origin.correlation !== null
-                ? [
-                    {
-                        name: "goal-continuation",
-                        text: boundedPrompt(ctx.config.continuation, ctx.config.promptLimit),
-                    },
-                ]
-                : []),
-        ];
-    }),
-    catalog: goalCatalog,
-    projection: {
-        schema: goalContract.projection.schema,
-        read: (ctx, sessionId) => {
-            const goal = Option.getOrUndefined(ctx.state.goals.peek(sessionId));
-            const endings = Option.getOrUndefined(ctx.state.endings.peek(sessionId));
-            if (goal === undefined && endings === undefined)
-                return Option.none();
-            const ended = endings?.ended ?? [];
-            return Option.some({
-                goal: goal === undefined ? null : committed(goal),
-                ended,
-                omitted: (endings?.total ?? 0) - ended.length,
-            });
         },
-    },
-    hooks: {
-        onSettled: (ctx, page) => Effect.forEach(page, (run) => settle(ctx, run), { discard: true }),
-    },
-    tools: (ctx, { sessionId, workId }) => Effect.succeed(Option.some(goalModule(ctx, sessionId, workId))),
-    commands: {
-        specs: goalContract.commands,
-        handlers: (ctx) => ({
-            goal: ({ sessionId, input }) => humanGoal(ctx, sessionId, input),
-            pause: ({ sessionId }) => pauseGoal(ctx, sessionId),
-            resume: ({ sessionId }) => resumeGoal(ctx, sessionId),
-            clear: ({ sessionId }) => clearGoal(ctx, sessionId).pipe(Effect.as({})),
-            set: ({ sessionId, input }) => setGoal(ctx, sessionId, input),
-        }),
-    },
-});
+        hooks: {
+            onSettled: (ctx, page) => Effect.forEach(page, (run) => settle(ctx, run, subagents), {
+                discard: true,
+            }),
+            onTimer: (ctx, timer) => recheckWaiting(ctx, timer, subagents),
+        },
+        tools: (ctx, { sessionId, workId }) => ctx.state.goals
+            .get(sessionId)
+            .pipe(Effect.map((found) => Option.some(goalModule(ctx, sessionId, workId, Option.isSome(found) ? found.value.revision : null)))),
+        commands: {
+            specs: goalContract.commands,
+            handlers: (ctx) => ({
+                goal: ({ sessionId, input }) => humanGoal(ctx, sessionId, input),
+                pause: ({ sessionId }) => pauseGoal(ctx, sessionId),
+                resume: ({ sessionId }) => resumeGoal(ctx, sessionId),
+                clear: ({ sessionId }) => clearGoal(ctx, sessionId).pipe(Effect.as({})),
+                set: ({ sessionId, input }) => setGoal(ctx, sessionId, input),
+            }),
+        },
+    }));
+}
+/** Ordinary roster when no created-Agent directory is available. */
+export const goalExtension = goalExtensionFor();