@fungi.computer/shiitake-extensions 0.2.0 → 0.4.0

package/dist/goal/prompts.d.ts

@@ -0,0 +1,73 @@
+import type { Goal } from "./contract.js";
+/** The `/goal` menu for a live or paused goal. */
+export declare function goalMenuPrompt(goal: Goal, now: number): {
+    type: "choice";
+    message: string;
+    summary: string;
+    facts: {
+        label: string;
+        value: string;
+    }[];
+    details: {
+        label: string;
+        value: string;
+    }[];
+    options: ({
+        value: string;
+        label: string;
+        destructive?: never;
+    } | {
+        value: string;
+        label: string;
+        destructive: true;
+    })[];
+} | {
+    body: string;
+    bodyLabel: string;
+    type: "choice";
+    message: string;
+    summary: string;
+    facts: {
+        label: string;
+        value: string;
+    }[];
+    details: {
+        label: string;
+        value: string;
+    }[];
+    options: ({
+        value: string;
+        label: string;
+        destructive?: never;
+    } | {
+        value: string;
+        label: string;
+        destructive: true;
+    })[];
+};
+/** The destructive step after choosing Clear: Keep is first and focused. */
+export declare const clearConfirmation: {
+    type: "confirmation";
+    message: string;
+    summary: string;
+    confirmLabel: string;
+    cancelLabel: string;
+    destructive: true;
+};
+/** The destructive step after typing a replacement goal. */
+export declare function replaceConfirmation(current: Goal, replacement: string): {
+    type: "confirmation";
+    message: string;
+    summary: string;
+    facts: {
+        label: string;
+        value: string;
+    }[];
+    details: {
+        label: string;
+        value: string;
+    }[];
+    confirmLabel: string;
+    cancelLabel: string;
+    destructive: true;
+};

package/dist/goal/prompts.js

@@ -0,0 +1,98 @@
+import { headline, titleLimit } from "../internal/headline.js";
+const pad = (value) => String(value).padStart(2, "0");
+/** A start time a person reads: 14:02 today, yesterday 14:02, or a full date. */
+function startedAt(epochMillis, now) {
+    const at = new Date(epochMillis);
+    const clock = `${pad(at.getHours())}:${pad(at.getMinutes())}`;
+    const day = (date) => new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime();
+    const days = Math.round((day(new Date(now)) - day(at)) / 86_400_000);
+    if (days === 0)
+        return `${clock} today`;
+    if (days === 1)
+        return `${clock} yesterday`;
+    return `${String(at.getFullYear())}-${pad(at.getMonth() + 1)}-${pad(at.getDate())} ${clock}`;
+}
+/** What happened, by the typed cause and never by the goal's own words. */
+const pausedSummary = {
+    person: "You paused this goal.",
+    blocked: "The Agent is stuck and needs you.",
+    stalled: "No progress for 3 turns, so Fungi paused it.",
+    cancelled: "You stopped the goal's turn.",
+    failed: "The last turn failed. Resume to try again.",
+    "no-terminal": "The goal's last turn ended without a final reply.",
+};
+const activeSummary = "Fungi keeps working until it is done or you pause it.";
+/** The `/goal` menu for a live or paused goal. */
+export function goalMenuPrompt(goal, now) {
+    const active = goal.state === "active";
+    const lead = active ? "Working on: " : "Goal paused: ";
+    const name = headline(goal.objective, titleLimit - lead.length);
+    const cause = goal.pauseCause;
+    const full = goal.objective.slice(0, 4_000);
+    const menu = {
+        type: "choice",
+        message: `${lead}${name}`,
+        summary: active ? activeSummary : pausedSummary[cause?.kind ?? "person"],
+        facts: [
+            { label: "Started", value: startedAt(goal.startedAt, now) },
+            ...(!active && cause?.kind === "blocked" && cause.detail != null
+                ? [{ label: "Why", value: `“${cause.detail.slice(0, 500)}”` }]
+                : []),
+        ],
+        details: [
+            { label: "Goal", value: full },
+            ...(cause === null
+                ? []
+                : [
+                    {
+                        label: "Paused",
+                        value: cause.detail == null
+                            ? cause.kind
+                            : `${cause.kind} · ${cause.detail.slice(0, 2_000)}`,
+                    },
+                ]),
+            { label: "Started", value: new Date(goal.startedAt).toLocaleString() },
+        ],
+        options: [
+            active
+                ? { value: "pause", label: "Pause goal" }
+                : { value: "resume", label: "Resume goal" },
+            { value: "replace", label: "Replace goal…" },
+            { value: "clear-ask", label: "Clear goal…", destructive: true },
+        ],
+    };
+    // A one-sentence goal is already the title; only longer text gets a body.
+    return full.replace(/\s+/gu, " ").trim() === name
+        ? menu
+        : { ...menu, body: full, bodyLabel: "Goal" };
+}
+/** The destructive step after choosing Clear: Keep is first and focused. */
+export const clearConfirmation = {
+    type: "confirmation",
+    message: "Clear this goal?",
+    summary: "It moves to history and can't be resumed.",
+    confirmLabel: "Clear goal",
+    cancelLabel: "Keep goal",
+    destructive: true,
+};
+/** The destructive step after typing a replacement goal. */
+export function replaceConfirmation(current, replacement) {
+    const old = current.objective.slice(0, 4_000);
+    const next = replacement.slice(0, 4_000);
+    return {
+        type: "confirmation",
+        message: `Replace the ${current.state === "active" ? "live" : "paused"} goal?`,
+        summary: "The current goal moves to history and can't be resumed.",
+        facts: [
+            { label: "Current", value: headline(old, 120) },
+            { label: "New", value: headline(next, 120) },
+        ],
+        details: [
+            { label: "Current", value: old },
+            { label: "New", value: next },
+        ],
+        confirmLabel: "Replace and start",
+        cancelLabel: "Keep current goal",
+        destructive: true,
+    };
+}

package/dist/home/host.js

@@ -100,14 +100,20 @@ export function homeExtension(options) {
                                 type: "info",
                                 message: "No Computers attached. Attach one before choosing Home.",
                             });
-                        return ask({
+                        const recorded = Option.getOrNull(yield* ctx.state.choice.get("default"));
+                        const home = computers.find(({ attachmentId }) => attachmentId === recorded?.attachmentId);
+                        const prompt = {
                             type: "choice",
-                            message: "Choose this Agent's Home Computer",
+                            message: "Choose a Home Computer",
+                            summary: "The Agent reads and edits files here by default.",
                             options: computers.map(({ name }) => ({
                                 value: name,
                                 label: name,
                             })),
-                        }, {}, "name");
+                        };
+                        return ask(home === undefined
+                            ? prompt
+                            : { ...prompt, current: home.name }, {}, "name");
                     }
                     const selected = computers.find(({ name }) => name === input.name);
                     if (selected === undefined)

package/dist/internal/headline.d.ts

@@ -0,0 +1,7 @@
+/** Longest title a modal carries. */
+export declare const titleLimit = 60;
+/**
+ * A short name for long user text: its first line's first sentence, whitespace collapsed
+ * and cut at a word to `limit` characters with an ellipsis.
+ */
+export declare function headline(objective: string, limit: number): string;

package/dist/internal/headline.js

@@ -0,0 +1,18 @@
+/** Longest title a modal carries. */
+export const titleLimit = 60;
+/**
+ * A short name for long user text: its first line's first sentence, whitespace collapsed
+ * and cut at a word to `limit` characters with an ellipsis.
+ */
+export function headline(objective, limit) {
+    const line = objective
+        .split("\n")
+        .map((part) => part.replace(/\s+/gu, " ").trim())
+        .find((part) => part !== "") ?? "";
+    const sentence = (/^.*?[.!?](?=\s|$)/u.exec(line)?.[0] ?? line).replace(/[.!?]+$/u, "");
+    if (sentence.length <= limit)
+        return sentence;
+    const cut = sentence.slice(0, Math.max(0, limit - 1));
+    const space = cut.lastIndexOf(" ");
+    return `${(space > limit / 2 ? cut.slice(0, space) : cut).trimEnd()}…`;
+}

package/dist/loop/client.js

@@ -74,7 +74,7 @@ export default defineClientEntry(loopContract, {
                     cancel: {
                         id: "loop",
                         label: "stop loop",
-                        input: { action: "stop" },
+                        input: { action: "stop-ask" },
                     },
                 }
                 : null,

package/dist/loop/contract.d.ts

@@ -54,7 +54,9 @@ export declare const LoopCommandInput: Schema.Union<readonly [Schema.Struct<{
     readonly requestId: Schema.String;
 }>, Schema.Struct<{
     /** Select an existing-loop control or open new-loop entry. */
-    readonly action: Schema.Literals<readonly ["status", "pause", "resume", "stop", "new"]>;
+    readonly action: Schema.Literals<readonly ["status", "pause", "resume", "stop", "stop-ask", "new"]>;
+    /** The human's answer to "stop this loop?"; absent for a typed stop. */
+    readonly confirmed: Schema.optional<Schema.Boolean>;
 }>, Schema.Struct<{}>]>;
 /** Loop's contract: Session-scope controls and one projection slot. */
 export declare const LoopProjection: Schema.Struct<{
@@ -111,7 +113,9 @@ export declare const loopContract: {
                 readonly requestId: Schema.String;
             }>, Schema.Struct<{
                 /** Select an existing-loop control or open new-loop entry. */
-                readonly action: Schema.Literals<readonly ["status", "pause", "resume", "stop", "new"]>;
+                readonly action: Schema.Literals<readonly ["status", "pause", "resume", "stop", "stop-ask", "new"]>;
+                /** The human's answer to "stop this loop?"; absent for a typed stop. */
+                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>;

package/dist/loop/contract.js

@@ -75,7 +75,16 @@ export const LoopCommandInput = Schema.Union([
     }),
     Schema.Struct({
         /** Select an existing-loop control or open new-loop entry. */
-        action: Schema.Literals(["status", "pause", "resume", "stop", "new"]),
+        action: Schema.Literals([
+            "status",
+            "pause",
+            "resume",
+            "stop",
+            "stop-ask",
+            "new",
+        ]),
+        /** The human's answer to "stop this loop?"; absent for a typed stop. */
+        confirmed: Schema.optional(Schema.Boolean),
     }),
     Schema.Struct({}),
 ]);

package/dist/loop/host.js

@@ -8,9 +8,10 @@ import * as Exit from "effect/Exit";
 import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
 import { z } from "zod";
-import { ask, catalog, done, freshRequestId } from "../internal/catalog.js";
+import { ask, catalog, declined, done, freshRequestId, } from "../internal/catalog.js";
 import { nextOccurrence } from "../internal/cron.js";
 import { Loop, LoopCommandInput, loopContract } from "./contract.js";
+import { loopMenuPrompt, stopConfirmation } from "./prompts.js";
 /** The rules the model follows; the describe page and a live loop's prompt share them. */
 const rules = "You may start loops yourself; one live loop per Session. Failed loop ticks retry with backoff; loop.get shows consecutiveFailures, lastError, and nextDueAt. schedule_next is allowed only in the active self-paced loop's own run, clamped to 60–3600 seconds. Omitting it ends that loop. stop works in any Session run. Human pause/resume/stop and Esc remain user controls.";
 /** Hashed prose and policy: every constant loop reads comes from here. */
@@ -521,7 +522,8 @@ function loopLine(loop) {
 }
 const loopPrompt = {
     type: "text",
-    message: "What should the loop repeat? Start with 5m or 1h for a fixed interval.",
+    message: "What should the loop repeat?",
+    summary: "Start with 5m or 1h for a fixed interval.",
     placeholder: "Check the build and fix what broke",
 };
 /** The human `/loop` conversation, decided from the committed loop. */
@@ -533,16 +535,7 @@ function humanLoop(ctx, sessionId, input) {
         if (!("action" in input)) {
             if (current === undefined || !live)
                 return ask(loopPrompt, { action: "start", requestId: yield* freshRequestId }, "text");
-            return ask({
-                type: "choice",
-                message: loopLine(current),
-                options: [
-                    current.state === "active"
-                        ? { value: "pause", label: "Pause loop" }
-                        : { value: "resume", label: "Resume loop" },
-                    { value: "stop", label: "Stop loop" },
-                ],
-            }, {}, "action");
+            return ask(loopMenuPrompt(current), {}, "action");
         }
         switch (input.action) {
             case "status":
@@ -564,7 +557,12 @@ function humanLoop(ctx, sessionId, input) {
                     type: "success",
                     message: loopLine(yield* resumeLoop(ctx, sessionId)),
                 });
+            case "stop-ask":
+                // The menu's Stop: Keep is the focused answer to this destructive step.
+                return ask(stopConfirmation, { action: "stop" }, "confirmed");
             case "stop":
+                if (input.confirmed === false)
+                    return declined({ type: "info", message: "Kept the loop." });
                 return done({
                     type: "success",
                     message: loopLine(yield* stopLoop(ctx, sessionId)),

package/dist/loop/prompts.d.ts

@@ -0,0 +1,56 @@
+import type { Loop } from "./contract.js";
+/** The `/loop` menu for a live or paused loop. */
+export declare function loopMenuPrompt(loop: Loop): {
+    type: "choice";
+    message: string;
+    summary: string;
+    facts: {
+        label: string;
+        value: string;
+    }[];
+    details: {
+        label: string;
+        value: string;
+    }[];
+    options: ({
+        value: string;
+        label: string;
+        destructive?: never;
+    } | {
+        value: string;
+        label: string;
+        destructive: true;
+    })[];
+} | {
+    body: string;
+    bodyLabel: string;
+    type: "choice";
+    message: string;
+    summary: string;
+    facts: {
+        label: string;
+        value: string;
+    }[];
+    details: {
+        label: string;
+        value: string;
+    }[];
+    options: ({
+        value: string;
+        label: string;
+        destructive?: never;
+    } | {
+        value: string;
+        label: string;
+        destructive: true;
+    })[];
+};
+/** The destructive step after choosing Stop: Keep is first and focused. */
+export declare const stopConfirmation: {
+    type: "confirmation";
+    message: string;
+    summary: string;
+    confirmLabel: string;
+    cancelLabel: string;
+    destructive: true;
+};

package/dist/loop/prompts.js

@@ -0,0 +1,54 @@
+import { headline, titleLimit } from "../internal/headline.js";
+/** The `/loop` menu for a live or paused loop. */
+export function loopMenuPrompt(loop) {
+    const active = loop.state === "active";
+    const lead = active ? "Loop running: " : "Loop paused: ";
+    const name = headline(loop.prompt, titleLimit - lead.length);
+    const full = loop.prompt.slice(0, 4_000);
+    const menu = {
+        type: "choice",
+        message: `${lead}${name}`,
+        summary: loop.mode === "self_paced"
+            ? "The Agent decides when to run it again."
+            : "It runs again on a fixed schedule.",
+        facts: [
+            {
+                label: "Mode",
+                value: loop.mode === "self_paced" ? "Self-paced" : "Fixed interval",
+            },
+            {
+                label: "Started",
+                value: loop.origin === "human" ? "By you" : "By the Agent",
+            },
+        ],
+        details: [
+            { label: "Prompt", value: full },
+            ...(loop.lastError === null
+                ? []
+                : [{ label: "Last error", value: loop.lastError.slice(0, 2_000) }]),
+            {
+                label: "Failures",
+                value: String(loop.consecutiveFailures),
+            },
+        ],
+        options: [
+            active
+                ? { value: "pause", label: "Pause loop" }
+                : { value: "resume", label: "Resume loop" },
+            { value: "stop-ask", label: "Stop loop…", destructive: true },
+        ],
+    };
+    // A short prompt is already the title; only longer text gets a body.
+    return full.replace(/\s+/gu, " ").trim() === name
+        ? menu
+        : { ...menu, body: full, bodyLabel: "Prompt" };
+}
+/** The destructive step after choosing Stop: Keep is first and focused. */
+export const stopConfirmation = {
+    type: "confirmation",
+    message: "Stop this loop?",
+    summary: "It won't run again. You can start a new one.",
+    confirmLabel: "Stop loop",
+    cancelLabel: "Keep loop",
+    destructive: true,
+};

package/dist/question/answer-flow.d.ts

@@ -0,0 +1,27 @@
+import type { WhistleCatalogStepV1 } from "@fungi.computer/whistle/catalog";
+import { ExtensionCommandError } from "@fungi.computer/shiitake/extensions";
+import * as Effect from "effect/Effect";
+import { type Answers, type AnswerFlowInput, type Question } from "./contract.js";
+import type * as Schema from "effect/Schema";
+/** Drafts travel in catalog arguments; only an owner's answer commits them. */
+export type FlowInput = Schema.Schema.Type<typeof AnswerFlowInput>;
+/** What the answer conversation does next for one open Ask. */
+export type AnswerFlowOutcome = Readonly<{
+    type: "step";
+    step: WhistleCatalogStepV1;
+}> | Readonly<{
+    type: "complete";
+    askId: string;
+    requestId: string;
+    answers: Answers;
+}>;
+/**
+ * Progress one Ask's answer draft by a single human step. The owner of the
+ * Ask commits a completed set; a step only ever returns the next prompt, so
+ * the same conversation serves the Ask's own Session and a parent's footer.
+ */
+export declare function advanceAnswerFlow(row: Readonly<{
+    askId: string;
+    questions: readonly Question[];
+    closed: boolean;
+}>, input: FlowInput): Effect.Effect<AnswerFlowOutcome, ExtensionCommandError>;

package/dist/question/answer-flow.js

@@ -0,0 +1,115 @@
+import { ExtensionCommandError } from "@fungi.computer/shiitake/extensions";
+import * as Effect from "effect/Effect";
+import { ask, done, freshRequestId } from "../internal/catalog.js";
+import { titleLimit } from "../internal/headline.js";
+import {} from "./contract.js";
+/** Accept only picks the question offered, and a non-empty answer. */
+function decisionAnswer(question, answer) {
+    const offered = new Set(question.options.map((option) => option.label));
+    const written = answer.text?.trim() ?? "";
+    if (answer.selected.some((label) => !offered.has(label)) ||
+        new Set(answer.selected).size !== answer.selected.length ||
+        (question.multiple !== true && answer.selected.length > 1) ||
+        (answer.selected.length === 0 && written === ""))
+        return Effect.fail(new ExtensionCommandError({
+            reason: "invalid",
+            message: "Choose offered options or write an answer",
+        }));
+    return Effect.succeed(written === ""
+        ? { selected: answer.selected }
+        : { selected: answer.selected, text: answer.text ?? "" });
+}
+/**
+ * The Agent's own words are the title only when they fit one; a longer
+ * question gets a plain title and sits in the body, whole in the details.
+ */
+function questionHeading(question) {
+    const text = question.question.replace(/\s+/gu, " ").trim();
+    if (text.length <= titleLimit)
+        return { message: text };
+    return {
+        message: "The Agent has a question",
+        body: question.question.slice(0, 4_000),
+        bodyLabel: "Question",
+        details: [{ label: "Question", value: question.question.slice(0, 4_000) }],
+    };
+}
+function promptQuestion(nextQuestion, next, total) {
+    const base = {
+        type: "decision",
+        ...questionHeading(nextQuestion),
+        options: nextQuestion.options.map((option) => ({
+            value: option.label,
+            label: option.label,
+            description: option.description,
+        })),
+        other: {
+            label: "Other…",
+            placeholder: "Write your own answer",
+            maxLength: 4_000,
+        },
+    };
+    // Only present fields travel: the wire is JSON, which has no undefined.
+    const numbered = total > 1
+        ? {
+            ...base,
+            summary: `Question ${String(next.index + 1)} of ${String(total)}`,
+        }
+        : base;
+    return ask(nextQuestion.multiple === true ? { ...numbered, multiple: true } : numbered, { stage: "decision", ...next }, "answer");
+}
+/**
+ * Progress one Ask's answer draft by a single human step. The owner of the
+ * Ask commits a completed set; a step only ever returns the next prompt, so
+ * the same conversation serves the Ask's own Session and a parent's footer.
+ */
+export function advanceAnswerFlow(row, input) {
+    return Effect.gen(function* () {
+        const draft = "stage" in input
+            ? input
+            : {
+                stage: "start",
+                index: 0,
+                requestId: yield* freshRequestId,
+                answers: {},
+            };
+        let { index, answers } = draft;
+        const { requestId } = draft;
+        const question = row.questions[index];
+        if (question === undefined)
+            return yield* Effect.fail(new ExtensionCommandError({
+                reason: "invalid",
+                message: "Unknown question step",
+            }));
+        const answer = draft.stage === "decision"
+            ? yield* decisionAnswer(question, draft.answer)
+            : undefined;
+        if (answer !== undefined) {
+            answers = { ...answers, [question.id]: answer };
+            index += 1;
+            if (index === row.questions.length)
+                return {
+                    type: "complete",
+                    askId: row.askId,
+                    requestId,
+                    answers,
+                };
+        }
+        if (row.closed)
+            return {
+                type: "step",
+                step: done({
+                    type: "info",
+                    message: "That question is already closed.",
+                }),
+            };
+        const next = { askId: row.askId, requestId, index, answers };
+        const nextQuestion = row.questions[index];
+        if (nextQuestion === undefined)
+            throw new Error("Expected the next question");
+        return {
+            type: "step",
+            step: promptQuestion(nextQuestion, next, row.questions.length),
+        };
+    });
+}

package/dist/question/client.d.ts

@@ -1,5 +1,5 @@
 import { type ClientContributionV1 } from "@fungi.computer/shiitake/client-entry";
-/** Pending decisions use the existing footer rows and advertised answer flow. */
+/** Pending decisions take over the composer; the footer row is where a postponed one waits. */
 declare const _default: Readonly<{
     protocol: "shiitake.client/v1";
     id: import("@fungi.computer/shiitake/extensions").ExtensionId;

package/dist/question/client.js

@@ -1,6 +1,6 @@
 import { defineClientEntry, } from "@fungi.computer/shiitake/client-entry";
 import { questionContract } from "./contract.js";
-/** Pending decisions use the existing footer rows and advertised answer flow. */
+/** Pending decisions take over the composer; the footer row is where a postponed one waits. */
 export default defineClientEntry(questionContract, {
     contribute: (view) => ({
         chips: [],
@@ -8,16 +8,35 @@ export default defineClientEntry(questionContract, {
             ? []
             : view.value.asks.map((ask) => {
                 const first = ask.questions[0];
+                const title = `${first?.question ?? "Question"}${ask.questions.length > 1 ? ` (+${String(ask.questions.length - 1)} more)` : ""}`;
+                const detail = first?.options.map((option) => option.label).join(" · ") ?? "";
+                // An ask waiting on an Agent is calm: it never takes over the
+                // composer, but a person may still answer it first.
+                if (ask.waitingOn !== undefined)
+                    return {
+                        id: ask.askId,
+                        title: `waiting on ${ask.waitingOn.name} · ${title}`,
+                        detail,
+                        tone: "muted",
+                        actions: [
+                            {
+                                id: "answerFlow",
+                                label: "Answer",
+                                input: { askId: ask.askId },
+                            },
+                        ],
+                    };
                 return {
                     id: ask.askId,
-                    title: `${first?.question ?? "Question"}${ask.questions.length > 1 ? ` (+${String(ask.questions.length - 1)} more)` : ""}`,
-                    detail: first?.options.map((option) => option.label).join(" · ") ?? "",
+                    title,
+                    detail,
                     tone: "attention",
                     actions: [
                         {
                             id: "answerFlow",
                             label: "Answer",
                             input: { askId: ask.askId },
+                            awaiting: "question",
                         },
                     ],
                 };