@fungi.computer/shiitake-extensions 0.0.2 → 0.1.1

package/dist/home/contract.js

@@ -4,22 +4,43 @@ import { CatalogStep } from "../internal/catalog.js";
 const attachmentId = Schema.String.pipe(Schema.check(Schema.isMinLength(1)));
 /** The Agent's recorded choice survives the chosen attachment being detached. */
 export const Home = Schema.Struct({
+    /** Chosen Computer attachment, or null when no Home is selected. */
     attachmentId: Schema.NullOr(attachmentId),
 });
 /** Human selection changes Agent state; no model operation exposes this command. */
 export const homeContract = {
+    /** Stable extension identity. */
     id: ExtensionId.make("botanical-home"),
+    /** Human selection and initial seeding operations. */
     commands: {
+        /** Open Home controls or select an attachment by name. */
         home: {
+            /** Human controls are opened from a Session. */
             scope: "session",
-            input: Schema.Struct({ name: Schema.optionalKey(Schema.String) }),
+            /** Decode an optional attachment name. */
+            input: Schema.Struct({
+                /** Attachment name selected by the person. */
+                name: Schema.optionalKey(Schema.String),
+            }),
+            /** Return the server-owned conversation step. */
             output: CatalogStep,
         },
+        /** Seed the Agent's initial recorded Home choice. */
         seed: {
+            /** Home selection belongs to the Agent. */
             scope: "agent",
+            /** Decode the initial selection. */
             input: Home,
-            output: Schema.Struct({ seeded: Schema.Boolean }),
+            /** Report whether seeding changed the recorded choice. */
+            output: Schema.Struct({
+                /** Whether the initial choice was seeded. */
+                seeded: Schema.Boolean,
+            }),
         },
     },
-    projection: { schema: Schema.NullOr(Home) },
+    /** Recorded selection visible to clients, or no seeded state. */
+    projection: {
+        /** Decoder for the optional Home state. */
+        schema: Schema.NullOr(Home),
+    },
 };

package/dist/home/host.d.ts

@@ -2,8 +2,11 @@ import { type FilesPort } from "@fungi.computer/knapsack";
 import { type ExtensionGrantV0, type RosteredExtensionV0 } from "@fungi.computer/shiitake/extensions";
 /** Already-scoped authority supplied by the host, never constructed by Home. */
 export type HomeComputer = Readonly<{
+    /** Attachment name offered to the person choosing Home. */
     name: string;
+    /** Stable identity stored by the Home selection. */
     attachmentId: string;
+    /** Already-scoped Files authority captured for this attachment. */
     port: FilesPort;
 }>;
 /** Hosts admit Home explicitly; no other extension receives the Files slot. */

package/dist/home/host.js

@@ -13,7 +13,7 @@ export const homeGrant = {
 };
 const config = {
     promptLimit: 4_000,
-    guide: "Home supplies read, list, glob and grep over your default Computer. Bare paths and computer://home/ use Home; computer://<name>/ uses that captured attachment. apply_patch, when offered, uses Home's native patch engine and path jail. Only a person changes Home with /home <name>; ask them when no Home is available.",
+    guide: "Home supplies read, list, glob and grep over your default Computer. Bare paths and computer://home/ use Home; computer://<name>/ uses that captured attachment. apply_patch, when offered, also works on Home. Only a person changes Home with /home <name>; ask them when no Home is available.",
 };
 const collections = {
     choice: defineCollection(Home, { key: () => "default" }),
@@ -79,7 +79,6 @@ export function homeExtension(options) {
                 return null;
             return Knapsack.files({
                 port: homeFilesRouting(new Map(computers.map(({ name, port }) => [name, port])), selected.port),
-                pathInstructions: "Bare paths and computer://home/ select Home. computer://<name>/ selects another captured attachment. apply_patch uses Home only.",
             }).tools;
         },
         prompt: (_ctx, run) => [

package/dist/home/routing.js

@@ -36,36 +36,15 @@ export function homeFilesRouting(connections, home) {
         },
         list: async (input, context) => {
             const { port, path, locate } = resolve(input.path);
-            const result = await port.list({ ...input, path }, context);
-            return {
-                ...result,
-                path: input.path,
-                entries: result.entries.map((entry) => ({
-                    ...entry,
-                    path: locate(entry.path),
-                })),
-            };
+            return locateSearch(await port.list({ ...input, path }, context), input.path, locate);
         },
         glob: async (input, context) => {
             const { port, path, locate } = resolve(input.path);
-            const result = await port.glob({ ...input, path }, context);
-            return {
-                ...result,
-                path: input.path,
-                matches: result.matches.map(locate),
-            };
+            return locateSearch(await port.glob({ ...input, path }, context), input.path, locate);
         },
         grep: async (input, context) => {
             const { port, path, locate } = resolve(input.path);
-            const result = await port.grep({ ...input, path }, context);
-            return {
-                ...result,
-                path: input.path,
-                matches: result.matches.map((match) => ({
-                    ...match,
-                    path: locate(match.path),
-                })),
-            };
+            return locateSearch(await port.grep({ ...input, path }, context), input.path, locate);
         },
         replace: async (input, context) => {
             const { port, path } = resolve(input.path);
@@ -78,3 +57,13 @@ export function homeFilesRouting(connections, home) {
     const patch = home.patch?.bind(home);
     return patch === undefined ? routing : { ...routing, patch };
 }
+function locateSearch(result, path, locate) {
+    return {
+        ...result,
+        path,
+        results: result.results.map((found) => ({
+            ...found,
+            path: locate(found.path),
+        })),
+    };
+}

package/dist/internal/history.d.ts

@@ -1,25 +1,41 @@
 import * as Schema from "effect/Schema";
 /** Producer state: committed event identity survives reconnection and trimming. */
 export declare function historySchema<E, EI>(event: Schema.Codec<E, EI>): Schema.Struct<{
+    /** Sequence to assign to the next committed event. */
     readonly nextSequence: Schema.Int;
+    /** Number of older events removed by retention. */
     readonly omitted: Schema.Int;
+    /** Retained committed events in sequence order. */
     readonly events: Schema.$Array<Schema.Struct<{
+        /** Stable event identity within this producer's history. */
         readonly id: Schema.String;
+        /** Producer-assigned event order. */
         readonly sequence: Schema.Int;
+        /** Event timestamp supplied by the owner. */
         readonly at: Schema.Int;
+        /** Associated accepted command, or null when none applies. */
         readonly commandId: Schema.NullOr<Schema.String>;
+        /** Extension-specific event payload. */
         readonly event: Schema.Codec<E, EI, never, never>;
     }>>;
 }>;
 /** The extension's own persisted history, not a core cursor. */
 export type History<E> = Readonly<{
+    /** Sequence to assign to the next committed event. */
     nextSequence: number;
+    /** Number of older events removed by retention. */
     omitted: number;
+    /** Retained committed events in sequence order. */
     events: readonly Readonly<{
+        /** Stable event identity within this producer's history. */
         id: string;
+        /** Producer-assigned event order. */
         sequence: number;
+        /** Event timestamp supplied by the owner. */
         at: number;
+        /** Associated accepted command, or null when none applies. */
         commandId: string | null;
+        /** Extension-specific event payload. */
         event: E;
     }>[];
 }>;

package/dist/internal/history.js

@@ -2,13 +2,21 @@ import * as Schema from "effect/Schema";
 /** Producer state: committed event identity survives reconnection and trimming. */
 export function historySchema(event) {
     return Schema.Struct({
+        /** Sequence to assign to the next committed event. */
         nextSequence: Schema.Int.check(Schema.isGreaterThan(0)),
+        /** Number of older events removed by retention. */
         omitted: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+        /** Retained committed events in sequence order. */
         events: Schema.Array(Schema.Struct({
+            /** Stable event identity within this producer's history. */
             id: Schema.String,
+            /** Producer-assigned event order. */
             sequence: Schema.Int,
+            /** Event timestamp supplied by the owner. */
             at: Schema.Int,
+            /** Associated accepted command, or null when none applies. */
             commandId: Schema.NullOr(Schema.String),
+            /** Extension-specific event payload. */
             event,
         })),
     });

package/dist/loop/client.d.ts

@@ -3,7 +3,7 @@ import { type ClientContributionV1 } from "@fungi.computer/shiitake/client-entry
 declare const _default: Readonly<{
     protocol: "shiitake.client/v1";
     id: import("@fungi.computer/shiitake/extensions").ExtensionId;
-    correlatedPrompts?: "note";
+    promptPresentation?: "footer";
     attach?: (context: import("@fungi.computer/shiitake/client-entry").ClientExtensionContextV1) => import("effect/Effect").Effect<void, Error, import("effect/Scope").Scope>;
     contribute?: (slot: import("@fungi.computer/shiitake").ExtensionSlotV0 | undefined) => ClientContributionV1;
 }>;

package/dist/loop/client.js

@@ -1,5 +1,10 @@
 import { defineClientEntry, } from "@fungi.computer/shiitake/client-entry";
 import { loopContract } from "./contract.js";
+/** One footer line: the full prompt stays in the row's detail. */
+const summary = (text) => {
+    const line = text.replace(/\s+/gu, " ").trim();
+    return line.length <= 60 ? line : `${line.slice(0, 59)}…`;
+};
 const tone = (loop) => loop.state === "failed"
     ? "error"
     : loop.state === "active"
@@ -17,6 +22,7 @@ const due = (at) => new Intl.DateTimeFormat(undefined, {
 }).format(at);
 /** Loop supplies its own absolute due copy and advertised stop intent. */
 export default defineClientEntry(loopContract, {
+    promptPresentation: "footer",
     contribute: (view) => {
         if (view.status !== "running" || view.value === null)
             return {
@@ -25,10 +31,10 @@ export default defineClientEntry(loopContract, {
                 timeline: { cells: [], omitted: 0 },
                 waiting: null,
             };
-        const { loop, history } = view.value;
-        const waiting = loop !== null && loop.state === "active" && loop.nextDueAt !== null;
+        const { loop } = view.value;
+        const waiting = loop.state === "active" && loop.nextDueAt !== null;
         return {
-            chips: loop === null || (loop.state !== "active" && loop.state !== "paused")
+            chips: loop.state !== "active" && loop.state !== "paused"
                 ? []
                 : [
                     {
@@ -41,39 +47,27 @@ export default defineClientEntry(loopContract, {
                         },
                     },
                 ],
-            panel: loop === null
-                ? []
-                : [
-                    {
-                        id: "loop",
-                        title: `Loop · ${loop.state} · ${loop.mode === "self_paced" ? "self-paced" : `${loop.cron?.expression ?? "fixed"} ${loop.cron?.timeZone ?? ""}`}${loop.nextDueAt === null ? "" : ` · Next ${due(loop.nextDueAt)}`}`,
-                        detail: loop.prompt.slice(0, 1024),
-                        tone: tone(loop),
-                    },
-                    ...(loop.lastError === null
-                        ? []
-                        : [
-                            {
-                                id: "error",
-                                title: loop.lastError.slice(0, 4096),
-                                tone: "error",
-                            },
-                        ]),
-                ],
-            timeline: {
-                omitted: history.omitted,
-                cells: history.events.map(({ event, ...cell }) => ({
-                    ...cell,
-                    rows: [
+            panel: [
+                {
+                    id: "loop",
+                    title: `Loop · ${loop.state} · ${loop.mode === "self_paced" ? "self-paced" : `${loop.cron?.expression ?? "fixed"} ${loop.cron?.timeZone ?? ""}`}${loop.nextDueAt === null ? "" : ` · Next ${due(loop.nextDueAt)}`} · ${summary(loop.prompt)}`,
+                    detail: [loop.reason, loop.prompt]
+                        .filter((part) => part !== null)
+                        .join("\n")
+                        .slice(0, 1024),
+                    tone: tone(loop),
+                },
+                ...(loop.lastError === null
+                    ? []
+                    : [
                         {
-                            id: "loop",
-                            title: `Loop ${event.state}`,
-                            detail: (event.lastError ?? event.reason ?? event.prompt).slice(0, 1024),
-                            tone: tone(event),
+                            id: "error",
+                            title: loop.lastError.slice(0, 4096),
+                            tone: "error",
                         },
-                    ],
-                })),
-            },
+                    ]),
+            ],
+            timeline: { cells: [], omitted: 0 },
             waiting: waiting
                 ? {
                     summary: `Waiting until ${due(loop.nextDueAt)}`,