@fungi.computer/shiitake 0.0.0-stage → 0.1.0

package/dist/internal/woodstock/session-entry.js

@@ -0,0 +1,484 @@
+import { CompactionInstructionsSchema } from "../client-boundary.js";
+import { HostMetaSchema } from "../host-meta.js";
+import { userContextMessage, VerifiedAgentReplySchema } from "./agent-reply.js";
+import { SandboxFailureEventSchema } from "@fungi.computer/mycelium";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import { ModelPreferenceSchema } from "../model-preference.js";
+const closed = { onExcessProperty: "error" };
+const encoder = new TextEncoder();
+const boundedText = (maximumBytes) => Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.makeFilter((value) => encoder.encode(value).byteLength <= maximumBytes)));
+const boundedId = boundedText(256);
+const digest = Schema.String.pipe(Schema.check(Schema.isPattern(/^[0-9a-f]{64}$/u)));
+const jsonValue = Schema.suspend(() => Schema.Union([
+    Schema.String,
+    Schema.Number,
+    Schema.Boolean,
+    Schema.Null,
+    Schema.Array(jsonValue),
+    Schema.Record(Schema.String, jsonValue),
+]));
+const textContent = Schema.Struct({
+    type: Schema.Literal("text"),
+    text: Schema.String,
+    textSignature: Schema.optionalKey(Schema.String),
+});
+const thinkingContent = Schema.Struct({
+    type: Schema.Literal("thinking"),
+    thinking: Schema.String,
+    thinkingSignature: Schema.optionalKey(Schema.String),
+    redacted: Schema.optionalKey(Schema.Boolean),
+});
+const imageContent = Schema.Struct({
+    type: Schema.Literal("image"),
+    data: Schema.String,
+    mimeType: Schema.String,
+});
+const StoredToolCallSchema = Schema.Struct({
+    type: Schema.Literal("toolCall"),
+    id: Schema.String,
+    name: Schema.String,
+    arguments: Schema.Record(Schema.String, jsonValue),
+    thoughtSignature: Schema.optionalKey(Schema.String),
+    namespace: Schema.optionalKey(Schema.String),
+});
+/** Provider-native usage grammar shared by stored messages and settlement facts. */
+export const usage = Schema.Struct({
+    input: Schema.Number,
+    output: Schema.Number,
+    cacheRead: Schema.Number,
+    cacheWrite: Schema.Number,
+    cacheWrite1h: Schema.optionalKey(Schema.Number),
+    reasoning: Schema.optionalKey(Schema.Number),
+    totalTokens: Schema.Number,
+    cost: Schema.Struct({
+        input: Schema.Number,
+        output: Schema.Number,
+        cacheRead: Schema.Number,
+        cacheWrite: Schema.Number,
+        total: Schema.Number,
+    }),
+});
+const userMessage = Schema.Struct({
+    role: Schema.Literal("user"),
+    content: Schema.Union([
+        Schema.String,
+        Schema.mutable(Schema.Array(Schema.Union([textContent, imageContent]))),
+    ]),
+    timestamp: Schema.Number,
+});
+const promptMessage = Schema.Struct({
+    role: Schema.Literal("user"),
+    content: Schema.String,
+    timestamp: Schema.Number,
+});
+const storedToolParameters = Schema.Record(Schema.String, jsonValue);
+const storedToolSampling = Schema.Union([
+    Schema.Literal(false),
+    Schema.Struct({
+        type: Schema.Literal("json_schema"),
+        strict: Schema.Literals(["prefer", "require"]),
+    }),
+    Schema.Struct({
+        type: Schema.Literal("grammar"),
+        variants: Schema.Struct({
+            openai_lark: Schema.optionalKey(Schema.String),
+            openai_regex: Schema.optionalKey(Schema.String),
+        }),
+    }),
+]);
+const storedPiTool = Schema.Struct({
+    name: Schema.String,
+    description: Schema.String,
+    parameters: storedToolParameters,
+    constrainedSampling: Schema.optionalKey(storedToolSampling),
+});
+const systemMessage = Schema.Struct({
+    role: Schema.Literal("system"),
+    content: Schema.Union([
+        Schema.String,
+        Schema.mutable(Schema.Array(textContent)),
+    ]),
+    sections: Schema.optionalKey(Schema.Record(Schema.String, Schema.Union([Schema.String, Schema.Null]))),
+    toolsAdded: Schema.optionalKey(Schema.mutable(Schema.Array(storedPiTool))),
+    toolsRemoved: Schema.optionalKey(Schema.mutable(Schema.Array(Schema.Struct({ name: Schema.String })))),
+    timestamp: Schema.Number,
+});
+const assistantMessage = Schema.Struct({
+    role: Schema.Literal("assistant"),
+    content: Schema.mutable(Schema.Array(Schema.Union([textContent, thinkingContent, StoredToolCallSchema]))),
+    api: Schema.String,
+    provider: Schema.String,
+    model: Schema.String,
+    responseModel: Schema.optionalKey(Schema.String),
+    responseId: Schema.optionalKey(Schema.String),
+    diagnostics: Schema.optionalKey(Schema.mutable(Schema.Array(Schema.Struct({
+        type: Schema.String,
+        timestamp: Schema.Number,
+        error: Schema.optionalKey(Schema.Struct({
+            name: Schema.optionalKey(Schema.String),
+            message: Schema.String,
+            stack: Schema.optionalKey(Schema.String),
+            code: Schema.optionalKey(Schema.Union([Schema.String, Schema.Number])),
+        })),
+        details: Schema.optionalKey(Schema.Record(Schema.String, jsonValue)),
+    })))),
+    usage,
+    stopReason: Schema.Literals([
+        "pending",
+        "stop",
+        "length",
+        "toolUse",
+        "error",
+        "aborted",
+        "deferred",
+    ]),
+    deferred: Schema.optionalKey(Schema.Struct({
+        provider: Schema.String,
+        modelId: Schema.String,
+        api: Schema.String,
+        id: Schema.String,
+        expiresAt: Schema.optionalKey(Schema.Number),
+        pollAfterMs: Schema.optionalKey(Schema.Number),
+        data: Schema.optionalKey(jsonValue),
+    })),
+    errorMessage: Schema.optionalKey(Schema.String),
+    rawStopReason: Schema.optionalKey(Schema.String),
+    providerThinkingLevel: Schema.optionalKey(Schema.String),
+    endTurn: Schema.optionalKey(Schema.Boolean),
+    timestamp: Schema.Number,
+});
+const toolResultMessage = Schema.Struct({
+    role: Schema.Literal("toolResult"),
+    toolCallId: Schema.String,
+    toolName: Schema.String,
+    content: Schema.mutable(Schema.Array(Schema.Union([textContent, imageContent]))),
+    details: Schema.optionalKey(jsonValue),
+    usage: Schema.optionalKey(usage),
+    isError: Schema.Boolean,
+    timestamp: Schema.Number,
+});
+/** Exact Pi message grammar stored by Woodstock without normalization. */
+export const StoredPiMessageSchema = Schema.Union([
+    systemMessage,
+    userMessage,
+    assistantMessage,
+    toolResultMessage,
+]);
+const causalKind = Schema.Literals([
+    "run",
+    "turn",
+    "message",
+    "tool_call",
+    "tool_result",
+    "terminal",
+]);
+const CausalIdentitySchema = Schema.suspend(() => Schema.Struct({
+    kind: causalKind,
+    value: boundedId,
+    parent: Schema.optional(CausalIdentitySchema),
+}));
+const LiveRetryEventSchema = Schema.Union([
+    Schema.Struct({
+        type: Schema.Literal("auto_retry_start"),
+        run: CausalIdentitySchema,
+        attempt: Schema.Number,
+        maxAttempts: Schema.Number,
+        delayMs: Schema.Number,
+        errorMessage: Schema.String,
+    }),
+    Schema.Struct({
+        type: Schema.Literal("auto_retry_attempt"),
+        run: CausalIdentitySchema,
+        attempt: Schema.Number,
+    }),
+    Schema.Struct({
+        type: Schema.Literal("auto_retry_end"),
+        run: CausalIdentitySchema,
+        attempt: Schema.Number,
+        success: Schema.Boolean,
+        finalError: Schema.optionalKey(Schema.String),
+    }),
+]);
+const fingerprint = Schema.String.pipe(Schema.check(Schema.isPattern(/^sha256:[0-9a-f]{64}$/u)));
+/**
+ * A roster fingerprint snapshot. Admission records what was offered then;
+ * execution facts record what the reopened owner actually ran.
+ */
+const runContract = Schema.Struct({
+    core: digest,
+    extensions: Schema.Array(Schema.Tuple([boundedId, fingerprint])).pipe(Schema.check(Schema.isMaxLength(128))),
+});
+const StoredToolResultSchema = Schema.Struct({
+    content: Schema.mutable(Schema.Array(Schema.Union([textContent, imageContent]))),
+    details: Schema.optional(jsonValue),
+    usage: Schema.optional(usage),
+    isError: Schema.Boolean,
+    terminate: Schema.optional(Schema.Boolean),
+});
+const common = { workId: boundedId };
+/** What started one compaction: the user, the context threshold, or an overflow. */
+const CompactionTriggerSchema = Schema.Literals([
+    "manual",
+    "threshold",
+    "overflow",
+]);
+/** Closed grammar stored in one retained Session entry JSON column. */
+const StoredSessionEntrySchema = Schema.Union([
+    Schema.Struct({
+        ...common,
+        kind: Schema.Literal("sandbox_failure"),
+        event: SandboxFailureEventSchema,
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("document"),
+        workId: Schema.Null,
+        extensionId: boundedId,
+        name: boundedId,
+        valueJson: Schema.String,
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("model_preference"),
+        workId: Schema.Null,
+        preference: Schema.NullOr(ModelPreferenceSchema),
+    }),
+    Schema.Struct({
+        ...common,
+        kind: Schema.Literal("command"),
+        meta: Schema.optionalKey(HostMetaSchema),
+        /** Present only when the host admitted this line as a verified Agent reply. */
+        reply: Schema.optionalKey(VerifiedAgentReplySchema),
+        delivery: Schema.optionalKey(Schema.Literals(["steer", "followUp"])),
+        requestId: boundedId,
+        targetWorkId: Schema.optionalKey(boundedId),
+        receiptId: boundedId,
+        message: userMessage,
+        contract: runContract,
+    }),
+    // A manual compaction request: accepted Session work with no message. It
+    // never enters model context, a title or the client message projection.
+    Schema.Struct({
+        ...common,
+        kind: Schema.Literal("command"),
+        work: Schema.Literal("compact"),
+        /** The user's focus for the summary, as Pi's `/compact <instructions>`. */
+        instructions: Schema.optionalKey(CompactionInstructionsSchema),
+        meta: Schema.optionalKey(HostMetaSchema),
+        requestId: boundedId,
+        receiptId: boundedId,
+        timestamp: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+        contract: runContract,
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("operator"),
+        workId: Schema.Null,
+        requestId: boundedId,
+        author: Schema.Literals(["operator", "party"]),
+        meta: Schema.optionalKey(HostMetaSchema),
+        message: promptMessage,
+    }),
+    Schema.Struct({
+        ...common,
+        kind: Schema.Literal("cancellation"),
+        requestId: boundedId,
+        receiptId: boundedId,
+        targetWorkId: boundedId,
+        meta: Schema.optionalKey(HostMetaSchema),
+    }),
+    Schema.Struct({
+        ...common,
+        kind: Schema.Literal("model_selection"),
+        provider: boundedId,
+        model: boundedId,
+        catalogRevision: boundedId,
+        definitionRevision: boundedId,
+        selectionPolicyRevision: boundedId,
+    }),
+    Schema.Struct({
+        ...common,
+        kind: Schema.Literal("run_started"),
+        run: CausalIdentitySchema,
+        contract: runContract,
+    }),
+    Schema.Struct({
+        ...common,
+        kind: Schema.Literal("turn_started"),
+        run: CausalIdentitySchema,
+        turn: CausalIdentitySchema,
+    }),
+    Schema.Struct({
+        ...common,
+        kind: Schema.Literal("model_prompt"),
+        run: CausalIdentitySchema,
+        turn: CausalIdentitySchema,
+        attempt: Schema.Number.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.isGreaterThan(0))),
+        contract: runContract,
+        systemPrompt: Schema.String.pipe(Schema.check(Schema.makeFilter((value) => encoder.encode(value).byteLength <= 1024 * 1024))),
+    }),
+    Schema.Struct({
+        ...common,
+        kind: Schema.Literal("message_start"),
+        run: CausalIdentitySchema,
+        turn: CausalIdentitySchema,
+        message: CausalIdentitySchema,
+        role: Schema.Literals(["assistant", "system", "toolResult", "user"]),
+    }),
+    Schema.Struct({
+        ...common,
+        kind: Schema.Literal("message"),
+        run: CausalIdentitySchema,
+        turn: CausalIdentitySchema,
+        message: CausalIdentitySchema,
+        value: StoredPiMessageSchema,
+    }),
+    Schema.Struct({
+        ...common,
+        kind: Schema.Literal("tool_intent"),
+        replay: Schema.Literals(["safe", "unsafe"]).pipe(Schema.withDecodingDefaultType(Effect.succeed("unsafe"))),
+        contract: runContract,
+        run: CausalIdentitySchema,
+        turn: CausalIdentitySchema,
+        toolCall: CausalIdentitySchema,
+        call: StoredToolCallSchema,
+    }),
+    Schema.Struct({
+        ...common,
+        kind: Schema.Literal("tool_outcome"),
+        run: CausalIdentitySchema,
+        turn: CausalIdentitySchema,
+        toolCall: CausalIdentitySchema,
+        call: StoredToolCallSchema,
+        result: StoredToolResultSchema,
+    }),
+    Schema.Struct({
+        ...common,
+        kind: Schema.Literal("live_retry"),
+        event: LiveRetryEventSchema,
+    }),
+    Schema.Struct({
+        ...common,
+        kind: Schema.Literal("compaction"),
+        resumesRun: Schema.optionalKey(Schema.Boolean),
+        // Optional only because Sessions compacted before these facts existed
+        // are still live; every new compaction records both.
+        trigger: Schema.optionalKey(CompactionTriggerSchema),
+        /** Estimated context tokens right after this compaction. */
+        tokensAfter: Schema.optionalKey(Schema.Number),
+        firstKeptEntryId: boundedId,
+        summary: Schema.String,
+        tokensBefore: Schema.Number,
+        usage,
+        contextRevision: boundedId,
+        details: Schema.optionalKey(Schema.Struct({
+            readFiles: Schema.Array(Schema.String),
+            modifiedFiles: Schema.Array(Schema.String),
+        })),
+    }),
+    // A compaction that committed nothing: a manual request with nothing to
+    // summarize, or any compaction that failed. Clients show it as a result.
+    Schema.Struct({
+        ...common,
+        kind: Schema.Literal("compaction_notice"),
+        trigger: CompactionTriggerSchema,
+        result: Schema.Literals(["nothing_to_compact", "failed"]),
+        diagnostic: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(200))),
+    }),
+    Schema.Struct({
+        ...common,
+        kind: Schema.Literal("run_terminal"),
+        run: CausalIdentitySchema,
+        terminal: CausalIdentitySchema,
+        outcome: Schema.Literals(["completed", "cancelled", "failed"]),
+    }),
+    Schema.Struct({
+        ...common,
+        kind: Schema.Literal("work_terminal"),
+        diagnostic: Schema.optionalKey(Schema.String),
+        outcome: Schema.Literals([
+            "completed",
+            "interrupted",
+            "cancelled",
+            "failed",
+        ]),
+    }),
+]);
+const StoredSessionEntryTextSchema = Schema.fromJsonString(StoredSessionEntrySchema);
+const JsonTextSchema = Schema.fromJsonString(Schema.Unknown);
+const decodeEntryJson = Schema.decodeUnknownResult(StoredSessionEntryTextSchema, closed);
+const encodeJson = Schema.encodeSync(JsonTextSchema);
+const validateEntryJson = Schema.decodeUnknownSync(StoredSessionEntryTextSchema, closed);
+/** Whether accepted work is a manual compaction request. */
+export function isCompactCommand(entry) {
+    return "work" in entry;
+}
+/** The prompt a command carries; a compaction request carries none. */
+export function promptCommand(entry) {
+    return entry.kind === "command" && !isCompactCommand(entry)
+        ? entry
+        : undefined;
+}
+/** When the command was accepted, as its own data records it. */
+export function commandTimestamp(entry) {
+    return isCompactCommand(entry) ? entry.timestamp : entry.message.timestamp;
+}
+/**
+ * What a later model run sees of an operator line: always a user-role note,
+ * so a human's words are never presented as the model's own output.
+ */
+export function operatorContextMessage(entry) {
+    return userContextMessage(entry.author === "party"
+        ? entry.message
+        : {
+            role: "user",
+            content: `[A human operator replied to the user on your behalf]\n${entry.message.content}`,
+            timestamp: entry.message.timestamp,
+        });
+}
+/**
+ * What a model run sees of an accepted command: its stored user line, wrapped
+ * as a verified Agent reply only when the host admitted it as one.
+ */
+export function commandContextMessage(entry) {
+    return userContextMessage(entry.message, entry.reply);
+}
+/**
+ * What a client sees of an operator line: the party's words as a user
+ * message, the operator's as an assistant message from provider `operator`.
+ */
+export function operatorClientMessage(entry) {
+    if (entry.author === "party")
+        return entry.message;
+    const zero = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
+    return {
+        role: "assistant",
+        content: [{ type: "text", text: entry.message.content }],
+        api: "operator",
+        provider: "operator",
+        model: "operator",
+        usage: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            totalTokens: 0,
+            cost: zero,
+        },
+        stopReason: "stop",
+        timestamp: entry.message.timestamp,
+    };
+}
+/** Decode the one JSON representation admitted by retained Session storage. */
+export function decodeStoredSessionEntry(value) {
+    return Result.map(decodeEntryJson(value), (entry) => entry.kind === "command" &&
+        !isCompactCommand(entry) &&
+        entry.delivery === undefined
+        ? { ...entry, delivery: "followUp" }
+        : entry);
+}
+/** Serialize Pi's JSON representation, then validate the retained entry. */
+export function encodeStoredSessionEntry(entry) {
+    const encoded = encodeJson(entry);
+    validateEntryJson(encoded);
+    return encoded;
+}

package/dist/internal/woodstock/session-grants.d.ts

@@ -0,0 +1,24 @@
+import type { Grants } from "@fungi.computer/mycelium";
+import type { SqliteOwner } from "../contracts.js";
+/** One versioned delivery of a Session's grants. */
+export type GrantsDelivery = Readonly<{
+    version: number;
+    grants: Grants;
+}>;
+/** Whether a delivery replaced the stored grants or repeated them. */
+export type GrantsDeliveryResult = "applied" | "unchanged";
+/** Woodstock keeps each Session's newest delivered grants beside it. */
+export declare function prepareSessionGrants(owner: SqliteOwner): void;
+/**
+ * Store one versioned delivery of a Session's grants. A delivery may arrive
+ * before the Session's first prompt. An older version is stale and never
+ * writes. The same version with other grants replaces the stored grants: the
+ * host recomputed its decision (for example after a deploy) without a new
+ * version, and the newest computation always wins over the old grant. Only
+ * the in-process host delivers grants.
+ */
+export declare function deliverSessionGrants(owner: SqliteOwner, sessionId: string, delivery: GrantsDelivery): GrantsDeliveryResult;
+/** One Session's newest delivery; null when the host delivered none. */
+export declare function readSessionGrants(owner: SqliteOwner, sessionId: string): GrantsDelivery | null;
+/** A fork keeps its source's delivery, so it never widens to the default. */
+export declare function copySessionGrants(owner: SqliteOwner, fromSessionId: string, toSessionId: string): void;

package/dist/internal/woodstock/session-grants.js

@@ -0,0 +1,84 @@
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { ShiitakeError } from "../../errors.js";
+/**
+ * One Session's tool grants as the host delivered them: module or extension
+ * ids mapped to a grant level. Bounded, so a host cannot grow the row.
+ */
+const SessionGrantsSchema = Schema.Record(Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(160)), Schema.Literals(["none", "read", "write"])).check(Schema.makeFilter((grants) => Object.keys(grants).length <= 256));
+/**
+ * One versioned delivery of a host decision. The host owns the decision and
+ * its version; Shiitake keeps only the newest delivery it has seen.
+ */
+const GrantsDeliverySchema = Schema.Struct({
+    /** The host's own version of this decision; deliveries only move forward. */
+    version: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER)),
+    grants: SessionGrantsSchema,
+});
+const decodeDelivery = Schema.decodeUnknownResult(GrantsDeliverySchema, {
+    onExcessProperty: "error",
+});
+const decodeStoredGrants = Schema.decodeUnknownResult(Schema.fromJsonString(SessionGrantsSchema));
+const encodeGrants = Schema.encodeSync(Schema.fromJsonString(SessionGrantsSchema));
+const decodeRow = Schema.decodeUnknownResult(Schema.Struct({ version: Schema.Int, grants_json: Schema.String }));
+/** Woodstock keeps each Session's newest delivered grants beside it. */
+export function prepareSessionGrants(owner) {
+    owner.sql.exec(`CREATE TABLE IF NOT EXISTS session_tool_grants (
+    session_id TEXT PRIMARY KEY,
+    version INTEGER NOT NULL,
+    grants_json TEXT NOT NULL
+  )`);
+}
+/**
+ * Store one versioned delivery of a Session's grants. A delivery may arrive
+ * before the Session's first prompt. An older version is stale and never
+ * writes. The same version with other grants replaces the stored grants: the
+ * host recomputed its decision (for example after a deploy) without a new
+ * version, and the newest computation always wins over the old grant. Only
+ * the in-process host delivers grants.
+ */
+export function deliverSessionGrants(owner, sessionId, delivery) {
+    const decoded = decodeDelivery(delivery);
+    if (Result.isFailure(decoded))
+        throw new ShiitakeError("contract", "invalid", "Session grants delivery is invalid");
+    const grantsJson = encodeGrants(decoded.success.grants);
+    const stored = readStoredRow(owner, sessionId);
+    if (stored !== undefined) {
+        if (decoded.success.version < stored.version)
+            throw new ShiitakeError("contract", "conflict", "Session grants delivery is older than the stored delivery");
+        if (decoded.success.version === stored.version &&
+            stored.grantsJson === grantsJson)
+            return "unchanged";
+    }
+    owner.sql.exec(`INSERT INTO session_tool_grants (session_id, version, grants_json)
+     VALUES (?, ?, ?)
+     ON CONFLICT(session_id) DO UPDATE SET
+       version = excluded.version, grants_json = excluded.grants_json`, sessionId, decoded.success.version, grantsJson);
+    return "applied";
+}
+function readStoredRow(owner, sessionId) {
+    const [raw] = owner.sql
+        .exec("SELECT version, grants_json FROM session_tool_grants WHERE session_id = ?", sessionId)
+        .toArray();
+    if (raw === undefined)
+        return undefined;
+    const row = decodeRow(raw);
+    if (Result.isFailure(row))
+        throw new ShiitakeError("store", "unavailable", "Stored Session grants are invalid");
+    return { version: row.success.version, grantsJson: row.success.grants_json };
+}
+/** One Session's newest delivery; null when the host delivered none. */
+export function readSessionGrants(owner, sessionId) {
+    const stored = readStoredRow(owner, sessionId);
+    if (stored === undefined)
+        return null;
+    const grants = decodeStoredGrants(stored.grantsJson);
+    if (Result.isFailure(grants))
+        throw new ShiitakeError("store", "unavailable", "Stored Session grants are invalid");
+    return { version: stored.version, grants: grants.success };
+}
+/** A fork keeps its source's delivery, so it never widens to the default. */
+export function copySessionGrants(owner, fromSessionId, toSessionId) {
+    owner.sql.exec(`INSERT INTO session_tool_grants (session_id, version, grants_json)
+     SELECT ?, version, grants_json FROM session_tool_grants WHERE session_id = ?`, toSessionId, fromSessionId);
+}

package/dist/internal/woodstock/session-inbox.d.ts

@@ -0,0 +1,56 @@
+import type { WatchdogQueueTransition } from "@fungi.computer/watchdog/effect";
+import type { SessionSummaryPage, SessionSummaryRow } from "../../client.js";
+import type { SqliteOwner } from "../contracts.js";
+/** Create the inbox table, its keyset and revision indexes and the revision clock. */
+export declare function prepareSessionInbox(owner: SqliteOwner): void;
+/** Conversation facts Woodstock supplies with each Session write. */
+export type SessionInboxFacts = Readonly<{
+    sessionId: string;
+    /** Conversation activity; absent for display-only writes such as a title. */
+    activityAt?: number;
+    /**
+     * First prompt title; null when the stored lineage is unreadable, and
+     * undefined when this write cannot change it.
+     */
+    title?: string | null;
+}>;
+/**
+ * Upsert title and recency in the caller's Session transaction. A new row
+ * starts `done`: nothing has run, and Watchdog's projector owns run state.
+ */
+export declare function touchSessionInbox(owner: SqliteOwner, facts: SessionInboxFacts): void;
+/** Record a deletion in the Session owner's transaction and revision stream. */
+export declare function recordSessionInboxDeletion(owner: SqliteOwner, sessionId: string): void;
+/** Drop tombstones the current member subscribers have all acknowledged. */
+export declare function pruneSessionInboxTombstones(owner: SqliteOwner, through: number): void;
+/**
+ * Watchdog's same-transaction projector. Queues that are not saved Sessions
+ * have no row and are left alone.
+ */
+export declare function projectSessionRun(owner: SqliteOwner, transition: WatchdogQueueTransition, now: number): void;
+/** Refresh attention using the current queue head in the extension transaction. */
+export declare function projectSessionAttention(owner: SqliteOwner, sessionId: string, head: WatchdogQueueTransition["head"]): void;
+/** Revisioned Session inbox changes after one owner revision, oldest first. */
+export type SessionInboxChanges = Readonly<{
+    rows: readonly (SessionSummaryRow | Readonly<{
+        sessionId: string;
+        deleted: true;
+    }>)[];
+    /** Revision of the last returned row, or `after` when none changed. */
+    through: number;
+    /** Latest owner revision; `through < latest` means more remain. */
+    latest: number;
+}>;
+/**
+ * A bounded strict-after read of changed rows. Each Session appears once, at
+ * its latest revision, so pending delivery is bounded by Session count.
+ */
+export declare function readSessionInboxChanges(owner: SqliteOwner, after: number, limit: number): SessionInboxChanges;
+/** Indexed lookup using the same row decoder and availability as the inbox listing. */
+export declare function readSessionInboxSummary(owner: SqliteOwner, sessionId: string): SessionSummaryRow | undefined;
+/**
+ * One bounded page in tier, then newest-activity order: a single indexed
+ * statement regardless of how many Sessions the Agent holds. A row whose
+ * stored facts are unreadable is its own `unavailable` row.
+ */
+export declare function readSessionInboxPage(owner: SqliteOwner, after: string | undefined): SessionSummaryPage;