@fungi.computer/shiitake-extensions 0.0.0-stage → 0.0.1

package/dist/subagents/host.js

@@ -0,0 +1,176 @@
+import { defineExtension, } from "@fungi.computer/shiitake/extensions";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { maximumSubagents, subagentsContract, } from "./contract.js";
+const defaultTiming = Object.freeze({
+    refreshMs: 1_000,
+    pollMs: 5_000,
+    interestMs: 30_000,
+});
+/** Sessions whose rows are held at once; the least recently read go first. */
+const cachedSessions = 64;
+/** Owner pages scanned for one child's row: 400 conversations. */
+const statusPages = 2;
+export const subagentsGrant = {
+    id: subagentsContract.id,
+    capabilities: ["projection"],
+};
+const settledState = {
+    running: "working",
+    needs_you: "waiting",
+    done: "idle",
+    errored: "failed",
+};
+/**
+ * The owner orders a page needs_you, running, then settled rows; a bounded
+ * scan finds the child's own row, and anything else is unavailable.
+ */
+async function findSession(agent, sessionId) {
+    let after;
+    for (let page = 0; page < statusPages; page += 1) {
+        const listed = await agent.listSessions(after);
+        const row = listed.sessions.find((item) => item.sessionId === sessionId);
+        if (row !== undefined || listed.next === undefined)
+            return row;
+        after = listed.next;
+    }
+    return undefined;
+}
+/** Read one child's owner-decided state; a failed read is unavailable, never idle. */
+async function status(source, record, signal) {
+    const base = {
+        agentId: record.agentId,
+        name: record.name,
+        sessionId: record.sessionId,
+    };
+    try {
+        const opened = await source.open(record.agentId, signal);
+        try {
+            if (record.sessionId === null)
+                return { ...base, state: "idle" };
+            const row = await findSession(opened.agent, record.sessionId);
+            if (row === undefined || row.state === "unavailable")
+                return { ...base, state: "unavailable" };
+            if (row.state !== "needs_you")
+                return { ...base, state: settledState[row.state] };
+            const snapshot = await opened.agent
+                .session(record.sessionId)
+                .read({ limit: 1 });
+            const attention = snapshot.attention[0]?.summary;
+            return attention === undefined
+                ? { ...base, state: "waiting" }
+                : { ...base, state: "waiting", attention };
+        }
+        finally {
+            await opened.release();
+        }
+    }
+    catch (cause) {
+        // The row shows unavailable; the operator log keeps why.
+        Effect.runFork(Effect.logWarning("subagents.status", cause));
+        return { ...base, state: "unavailable" };
+    }
+}
+const live = (value) => value?.agents.some((agent) => agent.state === "working" || agent.state === "waiting") === true;
+/**
+ * One activation's in-memory rows. A watcher's projection read refreshes
+ * stale rows outside the snapshot transaction; a changed or still-live result
+ * publishes one observation, whose re-read keeps interest alive.
+ */
+function createRoster(source, timing, publish) {
+    const entries = new Map();
+    const lifetime = new AbortController();
+    function forget(sessionId) {
+        clearTimeout(entries.get(sessionId)?.timer);
+        entries.delete(sessionId);
+    }
+    async function refresh(sessionId, entry) {
+        entry.refreshing = true;
+        clearTimeout(entry.timer);
+        entry.timer = undefined;
+        try {
+            const page = await source.read(sessionId, maximumSubagents - 1);
+            const value = {
+                agents: await Promise.all(page.agents
+                    .slice(0, maximumSubagents - 1)
+                    .map((record) => status(source, record, lifetime.signal))),
+                more: page.more,
+            };
+            const changed = JSON.stringify(value) !== JSON.stringify(entry.value);
+            entry.value = value;
+            if (!lifetime.signal.aborted && (changed || live(value)))
+                await publish(sessionId);
+        }
+        catch (cause) {
+            Effect.runFork(Effect.logError("subagents.refresh", cause));
+        }
+        finally {
+            entry.refreshedAt = Date.now();
+            entry.refreshing = false;
+        }
+        if (!lifetime.signal.aborted &&
+            entries.get(sessionId) === entry &&
+            live(entry.value) &&
+            Date.now() - entry.readAt < timing.interestMs)
+            entry.timer = setTimeout(() => {
+                void refresh(sessionId, entry);
+            }, timing.pollMs);
+    }
+    return {
+        read(sessionId) {
+            const now = Date.now();
+            let entry = entries.get(sessionId);
+            if (entry === undefined) {
+                entry = {
+                    value: undefined,
+                    refreshedAt: Number.NEGATIVE_INFINITY,
+                    readAt: now,
+                    refreshing: false,
+                    timer: undefined,
+                };
+                entries.set(sessionId, entry);
+                if (entries.size > cachedSessions) {
+                    const oldest = [...entries].sort(([, left], [, right]) => left.readAt - right.readAt)[0];
+                    if (oldest !== undefined)
+                        forget(oldest[0]);
+                }
+            }
+            entry.readAt = now;
+            if (!entry.refreshing && now - entry.refreshedAt >= timing.refreshMs)
+                void refresh(sessionId, entry);
+            return entry.value;
+        },
+        close() {
+            lifetime.abort();
+            for (const sessionId of entries.keys())
+                forget(sessionId);
+        },
+    };
+}
+/**
+ * The read-only sub-agent view: the Agents this conversation sent work to or
+ * created, one row each, with their live status. It owns no relationship,
+ * no durable state and no command; the collaboration App remains the only
+ * relationship owner.
+ */
+export function subagentsExtension(options) {
+    const rosters = new WeakMap();
+    return defineExtension({ id: subagentsContract.id, version: "1.0.0" })
+        .config({})
+        .define({
+        hooks: {
+            start: (ctx) => Effect.acquireRelease(Effect.sync(() => {
+                const roster = createRoster(options.source, options.timing ?? defaultTiming, (sessionId) => Effect.runPromise(ctx.transact(ctx.observe(sessionId)).pipe(Effect.ignore)));
+                rosters.set(ctx, roster);
+                return roster;
+            }), (roster) => Effect.sync(() => {
+                roster.close();
+                rosters.delete(ctx);
+            })).pipe(Effect.asVoid),
+        },
+        projection: {
+            schema: subagentsContract.projection.schema,
+            read: (ctx, sessionId) => Option.fromUndefinedOr(rosters.get(ctx)?.read(sessionId)),
+        },
+    });
+}

package/package.json

@@ -1,6 +1,120 @@
 {
   "name": "@fungi.computer/shiitake-extensions",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.1",
+  "author": "Levi <levi@technomancy.dev>",
+  "private": false,
+  "description": "Botanical's product Shiitake extensions: goal, loop and Almanac on the generic extension surface",
+  "type": "module",
+  "exports": {
+    "./almanac": {
+      "types": "./dist/almanac/contract.d.ts",
+      "import": "./dist/almanac/contract.js"
+    },
+    "./almanac/host": {
+      "types": "./dist/almanac/host.d.ts",
+      "import": "./dist/almanac/host.js"
+    },
+    "./question": {
+      "types": "./dist/question/contract.d.ts",
+      "import": "./dist/question/contract.js"
+    },
+    "./question/client": {
+      "types": "./dist/question/client.d.ts",
+      "import": "./dist/question/client.js"
+    },
+    "./question/host": {
+      "types": "./dist/question/host.d.ts",
+      "import": "./dist/question/host.js"
+    },
+    "./goal": {
+      "types": "./dist/goal/contract.d.ts",
+      "import": "./dist/goal/contract.js"
+    },
+    "./goal/host": {
+      "types": "./dist/goal/host.d.ts",
+      "import": "./dist/goal/host.js"
+    },
+    "./loop": {
+      "types": "./dist/loop/contract.d.ts",
+      "import": "./dist/loop/contract.js"
+    },
+    "./loop/host": {
+      "types": "./dist/loop/host.d.ts",
+      "import": "./dist/loop/host.js"
+    },
+    "./roster": {
+      "types": "./dist/roster.d.ts",
+      "import": "./dist/roster.js"
+    },
+    "./plan": {
+      "types": "./dist/plan/contract.d.ts",
+      "import": "./dist/plan/contract.js"
+    },
+    "./plan/host": {
+      "types": "./dist/plan/host.d.ts",
+      "import": "./dist/plan/host.js"
+    },
+    "./skills/source": {
+      "types": "./dist/skills/source.d.ts",
+      "import": "./dist/skills/source.js"
+    },
+    "./skills": {
+      "types": "./dist/skills/host.d.ts",
+      "import": "./dist/skills/host.js"
+    },
+    "./home": {
+      "types": "./dist/home/contract.d.ts",
+      "import": "./dist/home/contract.js"
+    },
+    "./home/host": {
+      "types": "./dist/home/host.d.ts",
+      "import": "./dist/home/host.js"
+    },
+    "./goal/client": {
+      "types": "./dist/goal/client.d.ts",
+      "import": "./dist/goal/client.js"
+    },
+    "./loop/client": {
+      "types": "./dist/loop/client.d.ts",
+      "import": "./dist/loop/client.js"
+    },
+    "./plan/client": {
+      "types": "./dist/plan/client.d.ts",
+      "import": "./dist/plan/client.js"
+    },
+    "./subagents": {
+      "types": "./dist/subagents/contract.d.ts",
+      "import": "./dist/subagents/contract.js"
+    },
+    "./subagents/host": {
+      "types": "./dist/subagents/host.d.ts",
+      "import": "./dist/subagents/host.js"
+    },
+    "./subagents/client": {
+      "types": "./dist/subagents/client.d.ts",
+      "import": "./dist/subagents/client.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@fungi.computer/almanac": "0.0.1",
+    "@fungi.computer/cairn": "0.0.1",
+    "@fungi.computer/knapsack": "0.0.2",
+    "@fungi.computer/mycelium": "0.0.2",
+    "@fungi.computer/shiitake": "0.1.0",
+    "@fungi.computer/whistle": "0.0.1",
+    "effect": "4.0.2",
+    "papaparse": "5.7.0",
+    "zod": "4.4.3",
+    "@fungi.computer/gills": "0.0.1"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fungi-computer/shiitake-extensions.git"
+  }
 }