@fungi.computer/shiitake-extensions 0.1.1 → 0.3.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.d.ts

@@ -14,8 +14,13 @@ export declare const homeGrant: ExtensionGrantV0;
 /** Agent-scope choice with per-run tools and prompt over one captured table. */
 export declare function homeExtension(options: {
     computers: {
+        /** Read the table inside the synchronous Home choice transaction. */
         read: (context: Readonly<{
             sessionId: string;
         }>) => readonly HomeComputer[];
+        /** Optional host preparation before run-scoped Files capture. */
+        prepare?: (context: Readonly<{
+            sessionId: string;
+        }>) => Promise<void>;
     };
 }): RosteredExtensionV0;

package/dist/home/host.js

@@ -51,7 +51,8 @@ export function homeExtension(options) {
             schema: Schema.NullOr(Home),
             read: (ctx) => Option.some(Option.getOrNull(ctx.state.choice.peek("default"))),
         },
-        files: (ctx, run) => {
+        files: async (ctx, run) => {
+            await options.computers.prepare?.(run);
             const computers = [...options.computers.read(run)];
             const choice = ctx.state.update((state) => {
                 const recorded = Option.getOrNull(state.choice.get("default"));
@@ -99,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/host.js

@@ -8,6 +8,7 @@ import * as Schema from "effect/Schema";
 import { createHash } from "node:crypto";
 import { z } from "zod";
 import Papa from "papaparse";
+import { titleLimit } from "../internal/headline.js";
 import { ask, catalog, done, freshRequestId } from "../internal/catalog.js";
 import { questionContract, OpenAsk, Questions, Answers, HumanResult, DeclineInput, ClosedStatus, AnswerFlowInput, } from "./contract.js";
 const config = {
@@ -695,15 +696,49 @@ function singleSelection(question, selection) {
         }))
         : Effect.succeed([option.label]);
 }
+/**
+ * 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) {
+    const heading = questionHeading(nextQuestion);
     if (nextQuestion.multiple === true)
         return ask({
             type: "text",
-            message: `${nextQuestion.question}\n${nextQuestion.options.map((option) => `${Papa.unparse([[option.label]])}: ${option.description}`).join("\n")}\nEnter selected labels as a comma list (quote labels containing commas), or leave blank for free text.`,
+            ...heading,
+            summary: `Separate your picks with commas, or leave blank to write your own.${nextQuestion.options.some((option) => option.label.includes(","))
+                ? " Put quotes around a pick that contains a comma."
+                : ""}`,
+            facts: [
+                {
+                    label: "Options",
+                    value: nextQuestion.options
+                        .map((option) => option.label)
+                        .join(" · "),
+                },
+            ],
+            details: [
+                ...("details" in heading ? heading.details : []),
+                ...nextQuestion.options.map((option) => ({
+                    label: option.label.slice(0, 200),
+                    value: option.description,
+                })),
+            ].slice(0, 24),
         }, { stage: "multiple", ...next }, "selection");
     return ask({
         type: "choice",
-        message: nextQuestion.question,
+        ...heading,
         options: [
             ...nextQuestion.options.map((option) => ({
                 value: `option:${option.label}`,

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

@@ -1,14 +1,16 @@
 import { type AgentControlDirectory } from "@fungi.computer/shiitake/agent-control";
 import type { CapabilitySource } from "@fungi.computer/mycelium";
 import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
-import { type SubagentSource } from "../subagents/host.js";
+import type { SubagentSource } from "../subagents/host.js";
 /** Host-pack creation admission; attachments/model selection retain their own owners. */
 export declare function assertOrdinaryAgentCreation(input: Parameters<NonNullable<AgentControlDirectory["create"]>>[0]): void;
 /**
  * This host's own record of the Agents each conversation created or sent
  * accepted work to, written as its Agent-control directory accepts them
- * (Wiki: agent-runtime-tools-and-clients, read-only sub-agent view). It feeds
- * the footer only; it owns no relationship and grants nothing.
+ * (Wiki: agent-runtime-tools-and-clients, read-only sub-agent view). Accepted
+ * child command receipts are separately reconciled against their owner's
+ * settlement records for the parent's goal guard. Neither record grants
+ * authority over a child.
  */
 export declare function createConversationAgents(storage: WatchdogSqliteOwner): {
     /** Bind acceptance recording to this conversation's existing directory. */
@@ -16,16 +18,10 @@ export declare function createConversationAgents(storage: WatchdogSqliteOwner):
     /** Agent-control tools bound to the conversation that acquires them. */
     control: (directoryFor: (parentSessionId: string | undefined) => AgentControlDirectory) => CapabilitySource;
     /** The footer rows for one conversation; archived and unknown Agents leave it. */
-    source: (directory: Pick<AgentControlDirectory, "list" | "open">) => SubagentSource;
+    source: (directory: Pick<AgentControlDirectory, "list"> & Pick<SubagentSource, "open">) => SubagentSource;
 };
 /** Both hosts compose the ordinary roster and its read-only created-Agent footer. */
-export declare function oysterAgentExtensions(source: SubagentSource): {
-    /** Ordinary extensions plus the read-only created-Agent footer. */
-    roster: import("@fungi.computer/shiitake").RosteredExtensionV0[];
-    /** Host grants corresponding to the composed extension roster. */
-    grants: Readonly<{
-        id: import("@fungi.computer/shiitake/extensions").ExtensionId;
-        capabilities: readonly import("@fungi.computer/shiitake").ExtensionCapabilityV0[];
-        grantKey?: string;
-    }>[];
-};
+export declare function oysterAgentExtensions(source: SubagentSource): Readonly<{
+    roster: readonly import("@fungi.computer/shiitake").RosteredExtensionV0[];
+    grants: readonly import("@fungi.computer/shiitake").ExtensionGrantV0[];
+}>;