@fungi.computer/shiitake-extensions 0.2.0 → 0.4.0

package/dist/goal/host.js

@@ -9,16 +9,23 @@ 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}). " +
+    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. If there is nothing to do until something outside this turn happens (a child's reply, a person, the train, main), call goal.wait({reason, fallbackMinutes}) and end the turn instead of polling.",
+    moduleDescription: "Session goal tools: create_goal({objective}), get_goal({}), update_goal({status:'complete'|'blocked'|'clear'|'resume', reason}), wait({reason, fallbackMinutes}). " +
         rules,
-    createDescription: "Create a Session goal, including autonomously. Fails while a goal is active or paused; a finished goal is history.",
+    createDescription: "Create a Session goal, including autonomously. Fails while a goal is active or paused; a finished goal is history. After update_goal complete (or clear on a paused goal) in this same run, it queues the replacement, which takes over when this run settles.",
     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,
+    waitDescription: "Say the goal is waiting on something outside this turn, then end the turn. The goal stays active and admits no goal turn and no stall count until another run in this Session settles (a child's reply, a person's message, a loop tick) or fallbackMinutes (default 20, 1 to 60) pass. Use it instead of polling.",
+    waitDefaultMinutes: 20,
+    waitMaxMinutes: 60,
+    waitingSummary: "Waiting on sub-agent",
+    waitingOnSummary: "Waiting",
     promptLimit: 1_024,
     stallTurns: 3,
     stallReason: "Stalled: no progress for 3 turns",
@@ -54,10 +61,21 @@ 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,
+    /**
+     * The goal waits on something outside its turns. `until` is null while the
+     * requesting run is still running; its settlement fixes the fallback instant.
+     */
+    waiting: Schema.optionalKey(Schema.NullOr(Schema.Struct({
+        reason: GoalReason,
+        fallbackMs: Schema.Int,
+        until: Schema.NullOr(Schema.Int),
+    }))),
+    /** A replacement objective queued after this run's complete or clear. */
+    successor: Schema.optionalKey(Schema.NullOr(Objective)),
     /** Request that set this revision; its retry replays. */
     revisionRequestId: Schema.String,
     /** Latest work whose settlement advances this goal. */
@@ -90,6 +108,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
@@ -123,6 +142,8 @@ function paused(goal, kind, detail) {
         state: "paused",
         pauseCause: { kind, detail },
         pending: null,
+        waiting: null,
+        successor: null,
     };
 }
 /**
@@ -150,6 +171,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. */
@@ -162,6 +184,7 @@ function changeActivity(ctx, sessionId, target) {
                 state: "active",
                 pauseCause: null,
                 stalledTurns: 0,
+                waiting: null,
             }
             : paused(goal, "person", null);
         yield* commitGoal(ctx, changed);
@@ -197,7 +220,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,24 +243,96 @@ function settle(ctx, run) {
             yield* commitGoal(ctx, paused(goal, "no-terminal", ctx.config.noTerminalReason));
             return yield* ctx.observe(run.sessionId);
         }
+        const goalTurn = run.origin?.extensionId === goalContract.id;
+        // A live child command or a question or approval a person has yet to
+        // answer is a legitimate wait, whether or not this turn polled.
+        const waitingForChild = goalTurn &&
+            (subagents?.hasLiveChildCommand(run.sessionId) === true ||
+                (yield* ctx.attention.awaitsPerson(run.sessionId)));
+        const waiting = goal.waiting ?? null;
+        // The run that called goal.wait fixes the fallback instant as it settles.
+        const requested = waiting !== null &&
+            waiting.until === null &&
+            run.workId === goal.trackedWorkId;
+        // Any other run that settles while a wait is armed wakes the goal.
+        const woken = waiting !== null && waiting.until !== null;
         const tracked = {
             ...goal,
             trackedWorkId: run.workId,
-            stalledTurns: run.origin?.extensionId === goalContract.id &&
-                run.origin.correlation === goal.revision
-                ? run.toolCalls === 0
-                    ? goal.stalledTurns + 1
-                    : 0
-                : goal.stalledTurns,
+            stalledTurns: requested
+                ? goal.stalledTurns
+                : run.origin?.extensionId === goalContract.id &&
+                    run.origin.correlation === goal.revision
+                    ? run.toolCalls === 0
+                        ? goal.stalledTurns + 1
+                        : 0
+                    : 0,
         };
         const pending = goal.trackedWorkId === run.workId ? goal.pending : null;
-        if (pending?.state === "complete")
-            yield* finishGoal(ctx, tracked, "achieved", pending.reason);
+        if (pending?.state === "complete" || pending?.state === "cleared") {
+            yield* ctx.timers.cancel(waitTimerKey(run.sessionId));
+            yield* finishGoal(ctx, tracked, pending.state === "complete" ? "achieved" : "cleared", pending.reason);
+            if (goal.successor != null) {
+                const next = {
+                    sessionId: run.sessionId,
+                    objective: goal.successor,
+                    state: "active",
+                    startedAt: yield* Clock.currentTimeMillis,
+                    pending: null,
+                    stalledTurns: 0,
+                    revision: `run:${run.workId}`,
+                    revisionRequestId: `run:${run.workId}`,
+                    trackedWorkId: run.workId,
+                    pauseCause: null,
+                    waiting: null,
+                    successor: null,
+                };
+                yield* commitGoal(ctx, yield* continueIfIdle(ctx, next, `goal-continue:${run.workId}`));
+            }
+        }
         else if (pending?.state === "blocked")
             yield* commitGoal(ctx, paused(tracked, "blocked", pending.reason));
+        else if (goal.state === "active" && requested) {
+            // goal.wait: no continuation and no stall; the next settled run or the
+            // fallback timer wakes the goal.
+            const now = yield* Clock.currentTimeMillis;
+            const until = now + waiting.fallbackMs;
+            yield* commitGoal(ctx, {
+                ...tracked,
+                waiting: { ...waiting, until },
+            });
+            yield* ctx.attention.set(run.sessionId, {
+                id: "waiting-goal",
+                kind: "goal-waiting",
+                inbox: false,
+                summary: `${ctx.config.waitingOnSummary}: ${waiting.reason}`.slice(0, 200),
+                since: now,
+            });
+            yield* ctx.timers.set(waitTimerKey(run.sessionId), until);
+        }
+        else if (goal.state === "active" && woken) {
+            yield* ctx.timers.cancel(waitTimerKey(run.sessionId));
+            yield* commitGoal(ctx, yield* continueIfIdle(ctx, { ...tracked, waiting: null }, `goal-continue:${run.workId}`));
+        }
         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 +340,37 @@ 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;
+        const armed = found.value.waiting ?? null;
+        if (armed !== null) {
+            // goal.wait's fallback: a re-armed wait ignores a stale firing.
+            if (armed.until === null || armed.until > timer.firedAt)
+                return;
+            return yield* commitGoal(ctx, yield* continueIfIdle(ctx, { ...found.value, waiting: null, stalledTurns: 0 }, `goal-wait:${found.value.trackedWorkId}`)).pipe(Effect.andThen(ctx.observe(sessionId)));
+        }
+        if (subagents?.hasLiveChildCommand(sessionId) === true ||
+            (yield* ctx.attention.awaitsPerson(sessionId)))
+            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 +393,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",
@@ -285,8 +426,21 @@ function goalModule(ctx, sessionId, workId) {
                 }),
                 execute: ({ objective }) => toolCall(ctx, "create_goal", Effect.gen(function* () {
                     const decoded = yield* Schema.decodeUnknownEffect(Objective)(objective).pipe(Effect.mapError(() => conflict("Goal objective is invalid")));
-                    if (Option.isSome(yield* ctx.state.goals.get(sessionId)))
-                        return yield* Effect.fail(conflict("A Session goal is already active or paused; only a person replaces it"));
+                    const existing = yield* ctx.state.goals.get(sessionId);
+                    if (Option.isSome(existing)) {
+                        // A goal this run already finished (complete, or clear of a
+                        // paused one) hands over to the replacement at settlement.
+                        const retiring = existing.value.trackedWorkId === workId &&
+                            (existing.value.pending?.state === "complete" ||
+                                existing.value.pending?.state === "cleared");
+                        if (!retiring)
+                            return yield* Effect.fail(conflict("A Session goal is already active or paused; complete it first, or only a person replaces it"));
+                        yield* ctx.state.goals.put({
+                            ...existing.value,
+                            successor: decoded,
+                        });
+                        return { objective: decoded, state: "active" };
+                    }
                     yield* commitGoal(ctx, {
                         sessionId,
                         objective: decoded,
@@ -298,6 +452,8 @@ function goalModule(ctx, sessionId, workId) {
                         revisionRequestId: `run:${workId}`,
                         trackedWorkId: workId,
                         pauseCause: null,
+                        waiting: null,
+                        successor: null,
                     });
                     yield* ctx.observe(sessionId);
                     return { objective: decoded, state: "active" };
@@ -325,39 +481,116 @@ function goalModule(ctx, sessionId, workId) {
                             null,
                     }))),
             }),
+            wait: Mycelium.operation({
+                replay: "unsafe",
+                description: ctx.config.waitDescription,
+                input: z.strictObject({
+                    reason: z.string().min(1).max(1_000),
+                    fallbackMinutes: z
+                        .number()
+                        .int()
+                        .min(1)
+                        .max(ctx.config.waitMaxMinutes)
+                        .optional(),
+                }),
+                output: z.strictObject({
+                    objective: toolObjective,
+                    state: z.literal("active"),
+                    reason: z.string(),
+                    fallbackMinutes: z.number().int(),
+                }),
+                execute: ({ reason, fallbackMinutes }) => toolCall(ctx, "wait", Effect.gen(function* () {
+                    const decoded = yield* Schema.decodeUnknownEffect(GoalReason)(reason).pipe(Effect.mapError(() => conflict("Wait reason is invalid")));
+                    const goal = yield* currentGoal;
+                    if (goal.state !== "active")
+                        return yield* Effect.fail(conflict("Only an active Session goal can wait"));
+                    if (goal.pending != null)
+                        return yield* Effect.fail(conflict("This run already requested a goal terminal"));
+                    const minutes = fallbackMinutes ?? ctx.config.waitDefaultMinutes;
+                    yield* ctx.state.goals.put({
+                        ...goal,
+                        // This run's settlement starts the wait.
+                        trackedWorkId: workId,
+                        waiting: {
+                            reason: decoded,
+                            fallbackMs: minutes * 60_000,
+                            until: null,
+                        },
+                    });
+                    return {
+                        objective: goal.objective,
+                        state: "active",
+                        reason: decoded,
+                        fallbackMinutes: minutes,
+                    };
+                })),
+            }),
             update_goal: Mycelium.operation({
                 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));
 }
@@ -377,15 +610,22 @@ function setGoal(ctx, sessionId, input) {
         const retried = current?.revisionRequestId === input.requestId;
         if (!retried && (current?.revision ?? null) !== input.expectedRevision)
             return yield* Effect.fail(conflict("Session goal changed; read it before replacing it"));
-        const admitted = yield* ctx.send({
-            sessionId,
-            when: "now",
-            prompt: {
-                text: input.objective,
-                requestId: input.requestId,
-                delivery: "followUp",
-            },
-        });
+        // Adopted work already carries the objective; anything else admits it.
+        const admitted = input.adoptCommandId === undefined
+            ? yield* ctx.send({
+                sessionId,
+                when: "now",
+                prompt: {
+                    text: input.objective,
+                    requestId: input.requestId,
+                    delivery: "followUp",
+                },
+            })
+            : {
+                _tag: "Accepted",
+                commandId: input.adoptCommandId,
+                delivery: retried ? "replay" : "new",
+            };
         if (admitted._tag !== "Accepted")
             return yield* Effect.fail(conflict("Session goal was not admitted"));
         const accepted = {
@@ -414,12 +654,20 @@ function setGoal(ctx, sessionId, input) {
             revisionRequestId: input.requestId,
             trackedWorkId: admitted.commandId,
             pauseCause: null,
+            waiting: null,
+            successor: null,
         };
-        yield* commitGoal(ctx, row);
+        // Adopted work that already settled left the Session idle: start the
+        // first goal turn now. Otherwise its settlement does.
+        const started = input.adoptCommandId === undefined
+            ? row
+            : yield* continueIfIdle(ctx, row, `goal-adopt:${input.requestId}`);
+        yield* commitGoal(ctx, started);
         yield* ctx.observe(sessionId);
-        return { goal: committed(row), accepted };
+        return { goal: committed(started), 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 +701,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 +725,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 +733,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 +792,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();