@fungi.computer/shiitake 0.0.0-stage → 0.0.1

package/dist/internal/woodstock/extension-store.d.ts

@@ -0,0 +1,72 @@
+import type { SqliteOwner } from "../contracts.js";
+/** Create every extension table. Idempotent `CREATE … IF NOT EXISTS` only. */
+export declare function prepareExtensionStore(owner: SqliteOwner): void;
+/** Read one encoded record value. */
+export declare function readRecord(owner: SqliteOwner, extensionId: string, collection: string, key: string): string | undefined;
+/** Read one key-ordered page of encoded record values. */
+export declare function readRecordPage(owner: SqliteOwner, extensionId: string, collection: string, query: Readonly<{
+    index?: string | undefined;
+    after?: string | undefined;
+    limit: number;
+}>): readonly string[];
+/** Upsert one encoded record. */
+export declare function writeRecord(owner: SqliteOwner, extensionId: string, collection: string, key: string, index: string | null, valueJson: string): void;
+/** Delete one record; absent keys are a no-op. */
+export declare function deleteRecord(owner: SqliteOwner, extensionId: string, collection: string, key: string): void;
+/** Every stored record of one extension, for activation-time migration. */
+export declare function readAllRecords(owner: SqliteOwner, extensionId: string): readonly Readonly<{
+    collection: string;
+    key: string;
+    valueJson: string;
+}>[];
+/** Remove every record of one extension inside a migration transaction. */
+export declare function deleteAllRecords(owner: SqliteOwner, extensionId: string): void;
+/** Stored state version and the revision that last wrote it. */
+export declare function readStateLedger(owner: SqliteOwner, extensionId: string): Readonly<{
+    version: number;
+    revision: string;
+}> | undefined;
+/** Record the state version an activation migrated to. */
+export declare function writeStateLedger(owner: SqliteOwner, extensionId: string, version: number, revision: string): void;
+/** Durable running/stopped state of one extension. */
+export type StoredExtensionStatus = Readonly<{
+    status: "running" | "stopped";
+    reason: string | null;
+    stoppedAt: number | null;
+    revision: string;
+}>;
+/** Read one extension's durable status. */
+export declare function readStatus(owner: SqliteOwner, extensionId: string): StoredExtensionStatus | undefined;
+/** Write one extension's durable status. */
+export declare function writeStatus(owner: SqliteOwner, extensionId: string, status: StoredExtensionStatus): void;
+/** Upsert one timer. */
+export declare function writeTimer(owner: SqliteOwner, extensionId: string, key: string, dueAt: number): void;
+/** Delete one timer; absent keys are a no-op. */
+export declare function deleteTimer(owner: SqliteOwner, extensionId: string, key: string): void;
+/** Read one timer's due instant. */
+export declare function readTimer(owner: SqliteOwner, extensionId: string, key: string): number | undefined;
+/** Due timers of the given extensions, oldest first, bounded by `limit`. */
+export declare function readDueTimers(owner: SqliteOwner, extensionIds: readonly string[], now: number, limit: number): readonly Readonly<{
+    extensionId: string;
+    key: string;
+    dueAt: number;
+}>[];
+/** Whether a timer is due now, and the next future timer instant. */
+export type TimerWake = Readonly<{
+    due: boolean;
+    nextWakeAt: number | null;
+}>;
+/** Whether a timer of the given extensions is due, and the next future one. */
+export declare function readTimerWake(owner: SqliteOwner, extensionIds: readonly string[], now: number): TimerWake;
+/**
+ * The one durable settled cursor table: one row per consumer (`core` or an
+ * extension identity).
+ *
+ * Watchdog's settled `sequence` is the enqueue order, not the settle order.
+ * Watchdog exposes only the settled prefix below the first unfinished serial
+ * row. That fence makes this high-water cursor exact across queue skips and
+ * concurrent delivery. Stream order is enqueue order, not completion order.
+ */
+export declare function readCursor(owner: SqliteOwner, consumer: string): number | undefined;
+/** Advance one consumer's cursor; it never moves backwards. */
+export declare function advanceCursor(owner: SqliteOwner, consumer: string, sequence: number): void;

package/dist/internal/woodstock/extension-store.js

@@ -0,0 +1,262 @@
+import * as Schema from "effect/Schema";
+import { ShiitakeError } from "../../errors.js";
+/**
+ * Core-owned durability for rostered v1 extensions.
+ *
+ * Every table is namespaced by extension identity, and only core writes SQL.
+ * An extension sees typed collections, timers and its own settled cursor
+ * through the runtime; it never receives this owner.
+ */
+const Text = Schema.String.pipe(Schema.check(Schema.isMinLength(1)));
+const Instant = Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)));
+const closed = { onExcessProperty: "error" };
+const ValueRowSchema = Schema.Struct({ value_json: Schema.String });
+const StateRowSchema = Schema.Struct({
+    state_version: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(1))),
+    revision: Text,
+});
+const StatusRowSchema = Schema.Struct({
+    status: Schema.Literals(["running", "stopped"]),
+    reason: Schema.NullOr(Schema.String),
+    stopped_at: Schema.NullOr(Instant),
+    revision: Text,
+});
+const TimerRowSchema = Schema.Struct({
+    extension_id: Text,
+    key: Text,
+    due_at: Instant,
+});
+const StoredRecordRowSchema = Schema.Struct({
+    collection: Text,
+    key: Text,
+    value_json: Schema.String,
+});
+const CursorRowSchema = Schema.Struct({ sequence: Instant });
+const WakeRowSchema = Schema.Struct({
+    due: Schema.Literals([0, 1]),
+    next_due_at: Schema.NullOr(Instant),
+});
+function unavailable(message) {
+    return new ShiitakeError("store", "unavailable", message);
+}
+function decodeRows(schema, rows, message) {
+    const decode = Schema.decodeUnknownResult(schema, closed);
+    return rows.map((row) => {
+        const decoded = decode(row);
+        if (decoded._tag === "Failure")
+            throw unavailable(message);
+        return decoded.success;
+    });
+}
+/** Create every extension table. Idempotent `CREATE … IF NOT EXISTS` only. */
+export function prepareExtensionStore(owner) {
+    owner.transactionSync(() => {
+        owner.sql.exec(`CREATE TABLE IF NOT EXISTS shiitake_extension_records (
+      extension_id TEXT NOT NULL,
+      collection TEXT NOT NULL,
+      key TEXT NOT NULL,
+      index_value TEXT,
+      value_json TEXT NOT NULL,
+      PRIMARY KEY (extension_id, collection, key)
+    )`);
+        owner.sql
+            .exec(`CREATE INDEX IF NOT EXISTS idx_shiitake_extension_records_index
+      ON shiitake_extension_records(extension_id, collection, index_value, key)`);
+        owner.sql.exec(`CREATE TABLE IF NOT EXISTS shiitake_extension_state (
+      extension_id TEXT PRIMARY KEY,
+      state_version INTEGER NOT NULL CHECK (state_version >= 1),
+      revision TEXT NOT NULL
+    )`);
+        owner.sql.exec(`CREATE TABLE IF NOT EXISTS shiitake_extension_status (
+      extension_id TEXT PRIMARY KEY,
+      status TEXT NOT NULL CHECK (status IN ('running', 'stopped')),
+      reason TEXT,
+      stopped_at INTEGER,
+      revision TEXT NOT NULL,
+      CHECK ((status = 'running') = (reason IS NULL)),
+      CHECK ((reason IS NULL) = (stopped_at IS NULL))
+    )`);
+        owner.sql.exec(`CREATE TABLE IF NOT EXISTS shiitake_extension_timers (
+      extension_id TEXT NOT NULL,
+      key TEXT NOT NULL,
+      due_at INTEGER NOT NULL CHECK (due_at >= 0),
+      PRIMARY KEY (extension_id, key)
+    )`);
+        owner.sql.exec(`CREATE INDEX IF NOT EXISTS idx_shiitake_extension_timers_due
+      ON shiitake_extension_timers(due_at, extension_id, key)`);
+        owner.sql.exec(`CREATE TABLE IF NOT EXISTS shiitake_settled_cursors (
+      consumer TEXT PRIMARY KEY,
+      sequence INTEGER NOT NULL CHECK (sequence >= 0)
+    )`);
+    });
+}
+// ---------- records ------------------------------------------------------------
+/** Read one encoded record value. */
+export function readRecord(owner, extensionId, collection, key) {
+    const rows = owner.sql
+        .exec(`SELECT value_json FROM shiitake_extension_records
+       WHERE extension_id = ? AND collection = ? AND key = ?`, extensionId, collection, key)
+        .toArray();
+    return decodeRows(ValueRowSchema, rows, "Stored extension record is invalid")[0]?.value_json;
+}
+/** Read one key-ordered page of encoded record values. */
+export function readRecordPage(owner, extensionId, collection, query) {
+    const rows = owner.sql
+        .exec(`SELECT value_json FROM shiitake_extension_records
+       WHERE extension_id = ? AND collection = ?
+         AND (? IS NULL OR index_value = ?)
+         AND (? IS NULL OR key > ?)
+       ORDER BY key LIMIT ?`, extensionId, collection, query.index ?? null, query.index ?? null, query.after ?? null, query.after ?? null, query.limit)
+        .toArray();
+    return decodeRows(ValueRowSchema, rows, "Stored extension record is invalid").map(({ value_json }) => value_json);
+}
+/** Upsert one encoded record. */
+export function writeRecord(owner, extensionId, collection, key, index, valueJson) {
+    owner.sql.exec(`INSERT INTO shiitake_extension_records
+       (extension_id, collection, key, index_value, value_json)
+     VALUES (?, ?, ?, ?, ?)
+     ON CONFLICT(extension_id, collection, key) DO UPDATE SET
+       index_value = excluded.index_value, value_json = excluded.value_json`, extensionId, collection, key, index, valueJson);
+}
+/** Delete one record; absent keys are a no-op. */
+export function deleteRecord(owner, extensionId, collection, key) {
+    owner.sql.exec(`DELETE FROM shiitake_extension_records
+     WHERE extension_id = ? AND collection = ? AND key = ?`, extensionId, collection, key);
+}
+/** Every stored record of one extension, for activation-time migration. */
+export function readAllRecords(owner, extensionId) {
+    const rows = owner.sql
+        .exec(`SELECT collection, key, value_json FROM shiitake_extension_records
+       WHERE extension_id = ? ORDER BY collection, key`, extensionId)
+        .toArray();
+    return decodeRows(StoredRecordRowSchema, rows, "Stored extension record is invalid").map((row) => ({
+        collection: row.collection,
+        key: row.key,
+        valueJson: row.value_json,
+    }));
+}
+/** Remove every record of one extension inside a migration transaction. */
+export function deleteAllRecords(owner, extensionId) {
+    owner.sql.exec("DELETE FROM shiitake_extension_records WHERE extension_id = ?", extensionId);
+}
+// ---------- migration ledger ---------------------------------------------------
+/** Stored state version and the revision that last wrote it. */
+export function readStateLedger(owner, extensionId) {
+    const rows = owner.sql
+        .exec(`SELECT state_version, revision FROM shiitake_extension_state
+       WHERE extension_id = ?`, extensionId)
+        .toArray();
+    const row = decodeRows(StateRowSchema, rows, "Extension ledger is invalid")[0];
+    return row === undefined
+        ? undefined
+        : { version: row.state_version, revision: row.revision };
+}
+/** Record the state version an activation migrated to. */
+export function writeStateLedger(owner, extensionId, version, revision) {
+    owner.sql.exec(`INSERT INTO shiitake_extension_state (extension_id, state_version, revision)
+     VALUES (?, ?, ?)
+     ON CONFLICT(extension_id) DO UPDATE SET
+       state_version = excluded.state_version, revision = excluded.revision`, extensionId, version, revision);
+}
+/** Read one extension's durable status. */
+export function readStatus(owner, extensionId) {
+    const rows = owner.sql
+        .exec(`SELECT status, reason, stopped_at, revision FROM shiitake_extension_status
+       WHERE extension_id = ?`, extensionId)
+        .toArray();
+    const row = decodeRows(StatusRowSchema, rows, "Extension status is invalid")[0];
+    return row === undefined
+        ? undefined
+        : {
+            status: row.status,
+            reason: row.reason,
+            stoppedAt: row.stopped_at,
+            revision: row.revision,
+        };
+}
+/** Write one extension's durable status. */
+export function writeStatus(owner, extensionId, status) {
+    owner.sql.exec(`INSERT INTO shiitake_extension_status
+       (extension_id, status, reason, stopped_at, revision)
+     VALUES (?, ?, ?, ?, ?)
+     ON CONFLICT(extension_id) DO UPDATE SET status = excluded.status,
+       reason = excluded.reason, stopped_at = excluded.stopped_at,
+       revision = excluded.revision`, extensionId, status.status, status.reason, status.stoppedAt, status.revision);
+}
+// ---------- timers -------------------------------------------------------------
+/** Upsert one timer. */
+export function writeTimer(owner, extensionId, key, dueAt) {
+    owner.sql.exec(`INSERT INTO shiitake_extension_timers (extension_id, key, due_at)
+     VALUES (?, ?, ?)
+     ON CONFLICT(extension_id, key) DO UPDATE SET due_at = excluded.due_at`, extensionId, key, dueAt);
+}
+/** Delete one timer; absent keys are a no-op. */
+export function deleteTimer(owner, extensionId, key) {
+    owner.sql.exec("DELETE FROM shiitake_extension_timers WHERE extension_id = ? AND key = ?", extensionId, key);
+}
+/** Read one timer's due instant. */
+export function readTimer(owner, extensionId, key) {
+    const rows = owner.sql
+        .exec(`SELECT extension_id, key, due_at FROM shiitake_extension_timers
+       WHERE extension_id = ? AND key = ?`, extensionId, key)
+        .toArray();
+    return decodeRows(TimerRowSchema, rows, "Extension timer is invalid")[0]
+        ?.due_at;
+}
+function placeholders(values) {
+    return values.map(() => "?").join(", ");
+}
+/** Due timers of the given extensions, oldest first, bounded by `limit`. */
+export function readDueTimers(owner, extensionIds, now, limit) {
+    if (extensionIds.length === 0)
+        return [];
+    const rows = owner.sql
+        .exec(`SELECT extension_id, key, due_at FROM shiitake_extension_timers
+       WHERE due_at <= ? AND extension_id IN (${placeholders(extensionIds)})
+       ORDER BY due_at, extension_id, key LIMIT ?`, now, ...extensionIds, limit)
+        .toArray();
+    return decodeRows(TimerRowSchema, rows, "Extension timer is invalid").map((row) => ({
+        extensionId: row.extension_id,
+        key: row.key,
+        dueAt: row.due_at,
+    }));
+}
+/** Whether a timer of the given extensions is due, and the next future one. */
+export function readTimerWake(owner, extensionIds, now) {
+    if (extensionIds.length === 0)
+        return { due: false, nextWakeAt: null };
+    const ids = placeholders(extensionIds);
+    const rows = owner.sql
+        .exec(`SELECT
+         EXISTS (SELECT 1 FROM shiitake_extension_timers
+                 WHERE due_at <= ? AND extension_id IN (${ids})) AS due,
+         (SELECT MIN(due_at) FROM shiitake_extension_timers
+          WHERE due_at > ? AND extension_id IN (${ids})) AS next_due_at`, now, ...extensionIds, now, ...extensionIds)
+        .toArray();
+    const row = decodeRows(WakeRowSchema, rows, "Extension timer is invalid")[0];
+    if (row === undefined)
+        throw unavailable("Extension timer is unavailable");
+    return { due: row.due === 1, nextWakeAt: row.next_due_at };
+}
+// ---------- settled cursors ----------------------------------------------------
+/**
+ * The one durable settled cursor table: one row per consumer (`core` or an
+ * extension identity).
+ *
+ * Watchdog's settled `sequence` is the enqueue order, not the settle order.
+ * Watchdog exposes only the settled prefix below the first unfinished serial
+ * row. That fence makes this high-water cursor exact across queue skips and
+ * concurrent delivery. Stream order is enqueue order, not completion order.
+ */
+export function readCursor(owner, consumer) {
+    const rows = owner.sql
+        .exec("SELECT sequence FROM shiitake_settled_cursors WHERE consumer = ?", consumer)
+        .toArray();
+    return decodeRows(CursorRowSchema, rows, "Settled cursor is invalid")[0]
+        ?.sequence;
+}
+/** Advance one consumer's cursor; it never moves backwards. */
+export function advanceCursor(owner, consumer, sequence) {
+    owner.sql.exec(`INSERT INTO shiitake_settled_cursors (consumer, sequence) VALUES (?, ?)
+     ON CONFLICT(consumer) DO UPDATE SET sequence = MAX(sequence, excluded.sequence)`, consumer, sequence);
+}

package/dist/internal/woodstock/fleet-store.d.ts

@@ -0,0 +1,32 @@
+import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
+/** Fleet identity and receipt storage; the caller owns the enclosing transaction. */
+export declare function createFleetDirectoryStore(sql: WatchdogSqliteOwner["sql"]): {
+    read: (agentId: string) => {
+        readonly [x: string]: string | number | ArrayBuffer | null;
+    } | undefined;
+    readReceipt: (requestId: string) => {
+        readonly [x: string]: string | number | ArrayBuffer | null;
+    } | undefined;
+    findByName: (name: string) => {
+        readonly [x: string]: string | number | ArrayBuffer | null;
+    } | undefined;
+    reserve(agentId: string, name: string, actorUserId: string, now: number, requestId: string, configuration: string): void;
+    list: () => readonly {
+        readonly [x: string]: string | number | ArrayBuffer | null;
+    }[];
+    rename(agentId: string, name: string, now: number): void;
+    listErasureIds: () => readonly string[];
+    erasureRosterComplete: () => boolean;
+    readCreator: (agentId: string) => {
+        readonly [x: string]: string | number | ArrayBuffer | null;
+    } | undefined;
+    remove(agentId: string): void;
+};
+/** Durable correspondence is frozen before delivery; retries reuse the same row. */
+export declare function createFleetDelegationStore(storage: WatchdogSqliteOwner): {
+    read: (requestId: string) => {
+        readonly [x: string]: string | number | ArrayBuffer | null;
+    } | undefined;
+    reserve(requestId: string, input: string, mail: string): void;
+    recordReceipt(requestId: string, receipt: string): void;
+};

package/dist/internal/woodstock/fleet-store.js

@@ -0,0 +1,93 @@
+import { z } from "zod";
+/** Fleet identity and receipt storage; the caller owns the enclosing transaction. */
+export function createFleetDirectoryStore(sql) {
+    const input = { sql };
+    input.sql.exec(`CREATE TABLE IF NOT EXISTS hub_team_agents (
+        agent_id TEXT PRIMARY KEY,
+        name TEXT NOT NULL UNIQUE,
+        actor_user_id TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      ) STRICT`);
+    input.sql.exec(`CREATE TABLE IF NOT EXISTS hub_team_agent_create_receipts (
+        request_id TEXT PRIMARY KEY,
+        actor_user_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        agent_id TEXT NOT NULL,
+        computer_mode TEXT NOT NULL,
+        FOREIGN KEY (agent_id) REFERENCES hub_team_agents (agent_id)
+      ) STRICT`);
+    // Team erasure must retain the DO address after a directory removal.
+    input.sql.exec(`CREATE TABLE IF NOT EXISTS hub_team_agent_erasure_ids (
+        agent_id TEXT PRIMARY KEY
+      ) STRICT`);
+    input.sql.exec(`CREATE TABLE IF NOT EXISTS hub_team_agent_erasure_scope (
+        singleton INTEGER PRIMARY KEY CHECK(singleton=1),
+        complete INTEGER NOT NULL CHECK(complete IN (0,1))
+      ) STRICT`);
+    input.sql.exec("INSERT OR IGNORE INTO hub_team_agent_erasure_scope(singleton,complete) VALUES (1,1)");
+    return {
+        read: (agentId) => input.sql
+            .exec("SELECT agent_id, name, actor_user_id, created_at, updated_at FROM hub_team_agents WHERE agent_id = ?", agentId)
+            .toArray()[0],
+        readReceipt: (requestId) => input.sql
+            .exec("SELECT request_id, actor_user_id, name, agent_id, computer_mode FROM hub_team_agent_create_receipts WHERE request_id = ?", requestId)
+            .toArray()[0],
+        findByName: (name) => input.sql
+            .exec("SELECT agent_id, name, actor_user_id, created_at, updated_at FROM hub_team_agents WHERE name = ?", name)
+            .toArray()[0],
+        reserve(agentId, name, actorUserId, now, requestId, configuration) {
+            input.sql.exec("INSERT INTO hub_team_agents (agent_id, name, actor_user_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?)", agentId, name, actorUserId, now, now);
+            input.sql.exec("INSERT INTO hub_team_agent_erasure_ids(agent_id) VALUES (?)", agentId);
+            input.sql.exec("INSERT INTO hub_team_agent_create_receipts (request_id, actor_user_id, name, agent_id, computer_mode) VALUES (?, ?, ?, ?, ?)", requestId, actorUserId, name, agentId, configuration);
+        },
+        list: () => input.sql
+            .exec("SELECT agent_id, name, actor_user_id, created_at, updated_at FROM hub_team_agents ORDER BY created_at DESC, agent_id DESC")
+            .toArray(),
+        rename(agentId, name, now) {
+            input.sql.exec("UPDATE hub_team_agents SET name = ?, updated_at = ? WHERE agent_id = ?", name, now, agentId);
+        },
+        listErasureIds,
+        erasureRosterComplete,
+        readCreator: (agentId) => input.sql
+            .exec("SELECT actor_user_id FROM hub_team_agents WHERE agent_id = ?", agentId)
+            .toArray()[0],
+        remove(agentId) {
+            input.sql.exec("DELETE FROM hub_team_agent_create_receipts WHERE agent_id = ?", agentId);
+            input.sql.exec("DELETE FROM hub_team_agents WHERE agent_id = ?", agentId);
+        },
+    };
+    function listErasureIds() {
+        return input.sql
+            .exec("SELECT agent_id FROM hub_team_agent_erasure_ids ORDER BY agent_id")
+            .toArray()
+            .map(({ agent_id }) => z.string().parse(agent_id));
+    }
+    function erasureRosterComplete() {
+        const row = input.sql
+            .exec("SELECT complete FROM hub_team_agent_erasure_scope WHERE singleton=1")
+            .toArray()[0];
+        return row?.complete === 1;
+    }
+}
+/** Durable correspondence is frozen before delivery; retries reuse the same row. */
+export function createFleetDelegationStore(storage) {
+    storage.sql.exec(`CREATE TABLE IF NOT EXISTS shiitake_fleet_delegations (
+    request_id TEXT PRIMARY KEY, input TEXT NOT NULL, mail TEXT NOT NULL, receipt TEXT
+  ) STRICT`);
+    return {
+        read: (requestId) => storage.sql
+            .exec("SELECT input, mail, receipt FROM shiitake_fleet_delegations WHERE request_id = ?", requestId)
+            .toArray()[0],
+        reserve(requestId, input, mail) {
+            storage.transactionSync(() => {
+                storage.sql.exec("INSERT OR IGNORE INTO shiitake_fleet_delegations(request_id, input, mail) VALUES (?, ?, ?)", requestId, input, mail);
+            });
+        },
+        recordReceipt(requestId, receipt) {
+            storage.transactionSync(() => {
+                storage.sql.exec("UPDATE shiitake_fleet_delegations SET receipt = ? WHERE request_id = ?", receipt, requestId);
+            });
+        },
+    };
+}

package/dist/internal/woodstock/identities.d.ts

@@ -0,0 +1,6 @@
+export declare const sessionIds: Readonly<{
+    readonly session: import("@fungi.computer/cairn").IdCodec<"session", "session", 1>;
+    readonly work: import("@fungi.computer/cairn").IdCodec<"session", "work", 1>;
+    readonly fact: import("@fungi.computer/cairn").IdCodec<"session", "fact", 1>;
+    readonly receipt: import("@fungi.computer/cairn").IdCodec<"session", "receipt", 1>;
+}>;

package/dist/internal/woodstock/identities.js

@@ -0,0 +1,11 @@
+import { defineIdFamily } from "@fungi.computer/cairn";
+export const sessionIds = defineIdFamily({
+    family: "session",
+    version: 1,
+    kinds: {
+        session: { prefix: "session" },
+        work: { prefix: "session_work" },
+        fact: { prefix: "session_fact" },
+        receipt: { prefix: "session_receipt" },
+    },
+});

package/dist/internal/woodstock/index.d.ts

@@ -0,0 +1,170 @@
+import type { SandboxFailureEvent } from "@fungi.computer/mycelium";
+import type { Json } from "../../extensions.js";
+import type { MuleError, MuleIdentity, MuleListener } from "@fungi.computer/mule/effect";
+import * as Effect from "effect/Effect";
+import type * as Scope from "effect/Scope";
+import type { ReadOptions, SessionExtensionSlots, SessionSnapshot } from "../../client.js";
+import { ShiitakeError } from "../../errors.js";
+import type { CommandSettlement, SqliteOwner } from "../contracts.js";
+import type { ObservedActivity } from "../session-status.js";
+import { type ClientReplayPage } from "./client-projection.js";
+import { type LiveRetryEvent } from "./session-entry.js";
+import { type CompactionNoticeInput, type AcceptedCommand, type EnqueueAcceptedWork, type AppendCompactionInput, type PreparedSessionRun, type RunContract, type RecordAcceptedCancellation, type SessionQueueHead, type StoredSessionRow } from "./session-store.js";
+export * from "./extension-store.js";
+export { createFleetDirectoryStore, createFleetDelegationStore, } from "./fleet-store.js";
+export * from "./session-attention.js";
+export { deliverSessionGrants, prepareSessionGrants, readSessionGrants, type GrantsDelivery, type GrantsDeliveryResult, } from "./session-grants.js";
+export * from "./progress.js";
+export * from "./compaction-activity.js";
+export * from "./agent-reply.js";
+export * from "./session-entry.js";
+export * from "./session-store.js";
+export * from "./session-inbox.js";
+export { contextMessageIds } from "./run-recovery.js";
+export * from "./storage-admission.js";
+/** Record one compaction notice and publish it to observers. */
+export declare function appendCompactionNotice(owner: SqliteOwner, input: CompactionNoticeInput): StoredSessionRow;
+/** Append compaction through Woodstock's ordinary owner-observation boundary. */
+export declare function appendCompactionTransition(owner: SqliteOwner, input: AppendCompactionInput): StoredSessionRow;
+/** Prepare Woodstock's retained Session and private admission schema. */
+export declare function prepareWoodstockSchema(owner: SqliteOwner): Effect.Effect<void, ShiitakeError>;
+/** Atomically cancel one exact owner-issued command. */
+export declare function cancelSession(owner: SqliteOwner, sessionId: string, commandId: string, onlyIfPending: boolean | undefined, readQueueHead: () => SessionQueueHead, record: RecordAcceptedCancellation, meta: Json | undefined): Effect.Effect<Readonly<{
+    accepted: Readonly<{
+        commandId: string;
+        entryId: string;
+    }>;
+    delivery: "new" | "replay";
+    active: boolean;
+}> | undefined, ShiitakeError, never>;
+/** Deliver one pending control through an active Mule safe point. */
+export declare function takeSessionControls(owner: SqliteOwner, input: Readonly<{
+    sessionId: string;
+    workId: string;
+    delivery: "steer" | "followUp";
+}>): Effect.Effect<readonly Readonly<{
+    workId: string;
+    requestId: string;
+    message: import("@fungi.computer/mule/effect").Message;
+}>[], ShiitakeError>;
+/** Record terminals for controls delivered through one settled parent run. */
+export declare function settleControls(owner: SqliteOwner, input: Readonly<{
+    sessionId: string;
+    parentWorkId: string;
+    outcome: "completed" | "cancelled" | "failed" | "interrupted";
+    enqueue: EnqueueAcceptedWork;
+}>): Effect.Effect<void, ShiitakeError>;
+/** Resolve Session-scoped abort to private work and record it atomically. */
+export declare function abortSession(owner: SqliteOwner, sessionId: string, readQueueHead: () => SessionQueueHead, record: RecordAcceptedCancellation, meta?: Json): Effect.Effect<Readonly<{
+    commandId: string;
+    entryId: string;
+}> | undefined, ShiitakeError, never>;
+/** Select one complete entry as the active Session lineage leaf. */
+export declare function branchSession(owner: SqliteOwner, input: Readonly<{
+    sessionId: string;
+    type: "branch";
+    entryId: string;
+    assertIdleSession: (queue: string) => void;
+}>): Effect.Effect<void, ShiitakeError>;
+/** Record one operator or party line on an idle Session; false on replay. */
+export declare function recordOperatorLine(owner: SqliteOwner, input: Readonly<{
+    sessionId: string;
+    requestId: string;
+    author: "operator" | "party";
+    meta: Json | undefined;
+    text: string;
+    assertIdleSession: (queue: string) => void;
+}>): Effect.Effect<void, ShiitakeError>;
+/** Fork one complete entry lineage into a new cold-readable Session. */
+export declare function forkSession(owner: SqliteOwner, input: Readonly<{
+    sessionId: string;
+    type: "fork";
+    entryId: string;
+    assertIdleSession: (queue: string) => void;
+}>): Effect.Effect<Readonly<{
+    sessionId: string;
+}>, ShiitakeError>;
+/** Load the exact retained lineage ending at one accepted command. */
+export declare function loadAcceptedRun(owner: SqliteOwner, input: Readonly<{
+    sessionId: string;
+    commandFactId: string;
+}>): Effect.Effect<PreparedSessionRun, ShiitakeError>;
+/** Read the last exact completed assistant text produced by accepted work. */
+export declare function readSettlementContent(owner: SqliteOwner, input: Readonly<{
+    sessionId: string;
+    commandFactId: string;
+}>): Effect.Effect<string, ShiitakeError>;
+/**
+ * The host metadata that settles with one accepted command: the
+ * cancellation's when a host-attributed cancel ended it, otherwise the
+ * command's own. Absent when the host attached none.
+ */
+export declare function readSettlementMeta(owner: SqliteOwner, input: Readonly<{
+    sessionId: string;
+    commandFactId: string;
+}>, outcome: "completed" | "cancelled" | "failed" | "interrupted" | "outcome_unknown"): Effect.Effect<Json | undefined, ShiitakeError>;
+/**
+ * The Session's recorded terminal diagnostic for one accepted command, the
+ * same text `agents.wait` and clients see; absent when none was recorded.
+ */
+export declare function readSettlementDiagnostic(owner: SqliteOwner, input: Readonly<{
+    sessionId: string;
+    commandFactId: string;
+}>): Effect.Effect<string | undefined, ShiitakeError>;
+/** Read one bounded public Session snapshot. */
+export declare function readSession(owner: SqliteOwner, sessionId: string, activity: ObservedActivity, input?: ReadOptions, projectExtensions?: () => SessionExtensionSlots): Effect.Effect<SessionSnapshot, ShiitakeError>;
+/** Read one bounded folder-resume summary through Woodstock's Effect boundary. */
+export declare function readSessionSummary(owner: SqliteOwner, sessionId: string): Effect.Effect<import("./session-store.js").StoredSessionSummary | undefined, ShiitakeError>;
+/**
+ * Persist or replay the Session reserved for a creation request ID.
+ * `admitNew` may refuse a new Session; a replayed request is never refused.
+ */
+export declare function createSession(owner: SqliteOwner, requestId: string, admitNew: () => void): Effect.Effect<string, ShiitakeError>;
+/** Permanently delete one idle Session; false when it does not exist. */
+export declare function deleteSession(owner: SqliteOwner, input: Readonly<{
+    sessionId: string;
+    assertIdleSession: (queue: string) => void;
+}>): Effect.Effect<boolean, ShiitakeError>;
+/** Read a page of stored conversation facts; status needs the Session owner. */
+export declare function readSessionFactPage(owner: SqliteOwner, after?: string): Effect.Effect<import("./session-store.js").StoredSessionSummaryPage, ShiitakeError>;
+/** Read one bounded inbox page in tier, then newest-activity order. */
+export declare function readSessionInbox(owner: SqliteOwner, after: string | undefined): Effect.Effect<import("../../client.js").SessionSummaryPage, ShiitakeError>;
+/** Read one strict-after page from Woodstock's selected lineage. */
+export declare function readSessionReplayPage(owner: SqliteOwner, sessionId: string, after: string | undefined, delivery: "replay" | "live", activity: ObservedActivity, projectExtensions?: () => SessionExtensionSlots, includeSandboxFailures?: boolean): Effect.Effect<ClientReplayPage, ShiitakeError>;
+/** Persist an operator-only sandbox diagnostic beside its accepted Session work. */
+export declare function recordSandboxFailure(owner: SqliteOwner, accepted: Pick<AcceptedCommand, "sessionId" | "commandId">, event: SandboxFailureEvent): Effect.Effect<void, ShiitakeError>;
+/** Extension that admitted one accepted command; null for other producers. */
+export type ExtensionAdmissionOrigin = Readonly<{
+    extensionId: string;
+    correlation: string | null;
+}> | null;
+/** Exact durable facts core joins into one settled run for extensions. */
+export type SettledRunFacts = Readonly<{
+    toolCalls: number;
+    /** Latest run or work terminal recorded for the work, if any. */
+    terminal: "completed" | "failed" | "cancelled" | "interrupted" | "missing";
+    origin: ExtensionAdmissionOrigin;
+}>;
+/** Read the admitting extension of one accepted command. */
+export declare function readExtensionAdmissionOrigin(owner: SqliteOwner, sessionId: string, commandFactId: string, workId: string): ExtensionAdmissionOrigin;
+/** Read the terminal and admission origin of one settled accepted command. */
+export declare function readSettledRunFacts(owner: SqliteOwner, sessionId: string, commandFactId: string, workId: string): SettledRunFacts;
+/** Record unsuccessful Watchdog settlement when Mule has no recorded terminal. */
+export declare function recordWorkSettlement(owner: SqliteOwner, input: Readonly<{
+    sessionId: string;
+    commandFactId: string;
+    workId: string;
+    /** `completed` settles work that runs no Mule turn, such as compaction. */
+    outcome: "completed" | "interrupted" | "cancelled" | "failed";
+    diagnostic?: string | undefined;
+}>): Effect.Effect<void, ShiitakeError>;
+/** Record one retained live Pi retry observation on the Session lineage. */
+export declare function recordLiveRetryEvent(owner: SqliteOwner, accepted: AcceptedCommand, event: LiveRetryEvent, turn: MuleIdentity): Effect.Effect<void, MuleError>;
+/**
+ * Open the one scoped listener that projects Mule's exact event stream into
+ * retained Session facts and bounded process-local progress.
+ */
+export declare function openMuleRecorder(owner: SqliteOwner, accepted: AcceptedCommand, contract: RunContract): Effect.Effect<MuleListener, never, Scope.Scope>;
+export { declareSessionDocument } from "./session-documents.js";
+/** Read exact settled work facts through Woodstock's native command/work indexes. */
+export declare function readCommandSettlement(owner: SqliteOwner, sessionId: string, commandId: string): Effect.Effect<CommandSettlement | undefined, ShiitakeError>;