@sigrun/sigrun 0.8.0 → 0.10.0

package/dist/server/routes/extensions.js

@@ -88,6 +88,11 @@ export function registerExtensionRoutes(app, ctx) {
                             ...(def.sharedData === true
                                 ? { sharedData: true }
                                 : {}),
+                            // The per-conversation opt-in (sparse: present only
+                            // when the panel opted in).
+                            ...(def.perConversation === true
+                                ? { perConversation: true }
+                                : {}),
                         })),
                     }),
             };

package/dist/server/routes/interactions.js

@@ -34,7 +34,7 @@
  */
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
 import { AmbientDoc, AmbientOwnersDoc, asAmbientRecord, } from "../../harness/ambient.js";
-import { InteractionDoc, InteractionsIndexDoc, answerFromBody, applyAnswer, asInteractionRecord, indexSettled, maskedAnswerValues, } from "../../harness/interactions.js";
+import { InteractionDoc, InteractionsIndexDoc, answerFromBody, applyAnswer, applyDecline, asInteractionRecord, indexSettled, maskedAnswerValues, sweepSecretDelivery, } from "../../harness/interactions.js";
 import { loadConversation } from "../conversation-handler.js";
 import { ID_PARAMS_SCHEMA, conversationId } from "../helpers.js";
 import { accessOf } from "@sigrun/shared/access";
@@ -221,6 +221,53 @@ export function registerInteractionRoutes(app, ctx) {
             answer: committed.answer,
         };
     });
+    // The decline route (ask-user Task 1): the answer route's peer — a
+    // human declines a DECLINABLE record (status "skipped", declinedVia
+    // "button"). Same access (write), same commit structure, same
+    // indexSettled + reply-after-commit; every successful decline sweeps
+    // the record's unread secret delivery inside the commit (the
+    // settleInteraction pattern). 404 unknown / 404 not-pending /
+    // 409 not-declinable.
+    app.post("/v1/conversations/:id/interactions/:callId/decline", {
+        schema: { params: ANSWER_PARAMS_SCHEMA },
+        preHandler: loadConversation(ctx, "write"),
+    }, async (request, reply) => {
+        const { callId } = request.params;
+        const conversation = request.conversation;
+        const committed = await conversation.commit(async (tx) => {
+            const draft = await tx.doc(InteractionDoc, conversation.id, callId, callId);
+            // Unknown callId: the doc materializes empty — kind "" never
+            // seeded (the answer route's detection).
+            if (draft.kind === "") {
+                return { found: false };
+            }
+            const outcome = applyDecline(draft, "button", Date.now(), request.principal.user);
+            if (outcome !== "declined") {
+                // A loser of the first-wins race never sweeps: the delivery
+                // (when there is one) belongs to the winner (the answer
+                // route's rule).
+                return { found: true, outcome };
+            }
+            const index = await tx.doc(InteractionsIndexDoc);
+            indexSettled(index, conversation.id, callId);
+            sweepSecretDelivery(conversation.id, callId);
+            return { found: true, outcome };
+        }, BACKGROUND_CONTEXT);
+        if (!committed.found) {
+            return await reply.code(404).send({ error: "no_such_interaction" });
+        }
+        if (committed.outcome === "not_pending") {
+            return await reply.code(404).send({ error: "not_pending" });
+        }
+        if (committed.outcome === "not_declinable") {
+            return await reply.code(409).send({ error: "not_declinable" });
+        }
+        return {
+            callId,
+            status: "skipped",
+            declinedVia: "button",
+        };
+    });
     // ─── Ambient seam ────────────────────────────────────────────────────
     // The conversation's ambient surfaces, replacement-state reads.
     app.get("/v1/conversations/:id/ambient", { schema: { params: ID_PARAMS_SCHEMA } }, async (request, reply) => {

package/dist/server/routes/meta.js

@@ -73,6 +73,12 @@ export function registerMetaRoutes(app, ctx) {
                                 // The §7.3 shared-data flag: channels refetch
                                 // fully when a since fetch answers ops-only.
                                 ...(def.sharedData === true ? { sharedData: true } : {}),
+                                // The per-conversation opt-in: channels attach the
+                                // panel with the open conversation's id (sparse —
+                                // present only when the panel opted in).
+                                ...(def.perConversation === true
+                                    ? { perConversation: true }
+                                    : {}),
                             })),
                         }),
                 };
@@ -174,6 +180,17 @@ export function registerMetaRoutes(app, ctx) {
                 providers: opened.providerCollisions,
                 commands: commandCatalog.collisions,
             },
+            // Knowledge C7: the published-hook registry — one row per OWNED
+            // hook name (`provider` is the owner slug; `shadowed` lists the
+            // losing providers). Empty when nothing published.
+            publishedHooks: opened.publishedHooks(),
+            // Warden Task 7: the decision-provider seam projection (the same
+            // pure-derivation discipline — the registry's boot-built rows).
+            decisions: {
+                providers: opened.decisions.providers(),
+                default: opened.decisions.resolvedDefault(),
+                collisions: opened.decisions.collisions(),
+            },
         };
     });
     // The slash-command catalog: the thin metadata list the composer's `/`

package/dist/server/routes/providers.js

@@ -87,8 +87,30 @@ function providerReadinessReport(opened) {
     for (const { id: providerId } of opened.models.getProviders()) {
         providers.push(readinessEntry(opened, providerId, producersByName));
     }
+    // Warden Task 7: decision providers append as their own entries
+    // (`kind: "decision"`, the model ids listed) — a decision provider
+    // whose id collides with a chat provider stays SEPARATE (distinct
+    // kinds, never merged).
+    for (const decision of opened.decisions.providers()) {
+        providers.push(decisionEntry(decision));
+    }
     return { providers };
 }
+/**
+ * One decision provider's report entry (warden Task 7): the registry
+ * row projected onto the shared entry shape — `models` the count,
+ * `modelIds` the bare ids, `owner` the contributing extension.
+ */
+function decisionEntry(decision) {
+    return {
+        provider: decision.id,
+        kind: "decision",
+        status: decision.status,
+        models: decision.models.length,
+        modelIds: decision.models,
+        owner: decision.extension,
+    };
+}
 /** Register the model-catalog and provider-readiness routes. */
 export function registerProviderRoutes(app, ctx) {
     const { opened } = ctx;
@@ -109,6 +131,35 @@ export function registerProviderRoutes(app, ctx) {
     // serves, so the 404 vocabulary matches it). Key material never
     // appears in any of these routes — statuses and counts only.
     const isKnownProvider = (providerId) => opened.models.getProvider(providerId) !== undefined;
+    // Warden Task 7: a DECISION-only provider id is equally routable (the
+    // registry enumerates its ids). The mutation bodies branch on the
+    // kind: chat ids refresh, decision ids re-read — the registry
+    // derives readiness per call, so a credential write is visible
+    // without a refresh (and the decision seam has no catalog leg to
+    // refresh).
+    const isDecisionProvider = (providerId) => opened.decisions.providers().some((row) => row.id === providerId);
+    const isRoutableProvider = (providerId) => isKnownProvider(providerId) || isDecisionProvider(providerId);
+    // The entry back from a mutation: the chat derivation for catalog
+    // providers, the decision entry for decision-only ids (a chat AND
+    // decision provider sharing an id answer the CHAT entry — the
+    // mutation there targets the catalog provider's refresh leg).
+    const routableEntry = (providerId) => {
+        if (isKnownProvider(providerId)) {
+            return readinessEntry(opened, providerId, producersIndex(opened));
+        }
+        const decision = opened.decisions
+            .providers()
+            .find((row) => row.id === providerId);
+        if (decision === undefined) {
+            throw new Error(`provider "${providerId}" is not routable`);
+        }
+        return decisionEntry(decision);
+    };
+    // The post-write refresh: chat ids only.
+    const refreshAfterWrite = async (providerId) => {
+        if (isKnownProvider(providerId))
+            await opened.refreshProvider(providerId);
+    };
     // One bounded refresh of the named provider (W3 Task 6, spec §7.6):
     // the SAME policy the boot/interval/refresh-on-miss paths run — bounded
     // by the deadline, failures warned (never the route's error), a
@@ -138,7 +189,7 @@ export function registerProviderRoutes(app, ctx) {
             return await reply.code(403).send({ error: "forbidden" });
         }
         const { id } = request.params;
-        if (!isKnownProvider(id)) {
+        if (!isRoutableProvider(id)) {
             return await reply.code(404).send({ error: "provider_not_found" });
         }
         const body = request.body;
@@ -153,9 +204,14 @@ export function registerProviderRoutes(app, ctx) {
                 .code(400)
                 .send({ error: "invalid_field", field: "apiKey" });
         }
-        await opened.auth.setApiKey(credentialKey(id), apiKey);
-        await opened.refreshProvider(id);
-        return readinessEntry(opened, id, producersIndex(opened));
+        // The credential key: chat ids redirect the DEFAULT provider's id
+        // to the magic "default" key; decision-only ids use the id
+        // verbatim (the magic key names the default CHAT provider, never a
+        // decision credential).
+        const key = isKnownProvider(id) ? credentialKey(id) : id;
+        await opened.auth.setApiKey(key, apiKey);
+        await refreshAfterWrite(id);
+        return routableEntry(id);
     });
     // Remove the provider's credential (admin): store delete of that SAME
     // key → one refresh → the entry. Restart-free the same way — the
@@ -165,12 +221,13 @@ export function registerProviderRoutes(app, ctx) {
             return await reply.code(403).send({ error: "forbidden" });
         }
         const { id } = request.params;
-        if (!isKnownProvider(id)) {
+        if (!isRoutableProvider(id)) {
             return await reply.code(404).send({ error: "provider_not_found" });
         }
-        await opened.auth.deleteApiKey(credentialKey(id));
-        await opened.refreshProvider(id);
-        return readinessEntry(opened, id, producersIndex(opened));
+        const key = isKnownProvider(id) ? credentialKey(id) : id;
+        await opened.auth.deleteApiKey(key);
+        await refreshAfterWrite(id);
+        return routableEntry(id);
     });
     // Models: the merged chat-model catalog as picker entries (no provider
     // internals — baseUrl/headers/auth stay server-side). The shared

package/dist/server/routes/submissions.js

@@ -52,6 +52,9 @@ export function registerSubmissionRoutes(app, ctx) {
                     ? {}
                     : { user: request.principal.user }),
                 ...(body.whenBusy === undefined ? {} : { whenBusy: body.whenBusy }),
+                // Ask-user Task 2: a human's message through the HTTP submit
+                // route declines pending declinable questions (spec §5.3).
+                declinesQuestions: true,
                 ...(request.query?.waitMs ===
                     undefined
                     ? {}

package/dist/settings/registry.js

@@ -133,6 +133,18 @@ export const CORE_SETTING_KEYS = [
         section: "general",
         reason: "read per settled run by the auto-namer (src/harness/naming.ts)",
     },
+    {
+        key: "decisionModel",
+        apply: "live",
+        section: "general",
+        reason: "read per host.decisions.evaluate call by the decision registry (src/harness/decisions.ts)",
+    },
+    {
+        key: "decisions.tool",
+        apply: "live",
+        section: "tools",
+        reason: "read at each decision_evaluate tool call (default off)",
+    },
     {
         key: "defaultProvider.baseUrl",
         apply: "restart",
@@ -332,6 +344,12 @@ export const CORE_SETTING_KEYS = [
         section: "advanced",
         reason: "the event bus's queue bound is set at open (boot)",
     },
+    {
+        key: "server.decisions.timeoutMs",
+        apply: "live",
+        section: "providers",
+        reason: "the decision registry reads the settings' timeoutMs per evaluate call (src/harness/decisions.ts)",
+    },
     {
         key: "server.providers.refreshIntervalMinutes",
         apply: "live",

package/node_modules/@sigrun/shared/CHANGELOG.md

@@ -6,6 +6,18 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 
+## [0.10.0] - 2026-11-06
+
+- `JobSpec.description?: string` (and the flattened `JobWire.description`): the optional,
+  trimmed, ≤500-char human description shown in the Jobs view.
+
+## [0.9.0] - 2026-11-05
+
+- `InteractionRecord` gains optional `declinable: true` and settled `declinedVia:
+  "button" | "message"` (the ask-user decline wire surface — additive, optional).
+- `InteractionDeclined` wire type beside `InteractionAnswered` (the decline route's
+  200 body).
+
 ## [0.8.0] - 2026-11-04
 
 - New `./notices` subpath: the `UserNotice*` wire types, `NOTICE_LIMITS`, and the

package/node_modules/@sigrun/shared/dist/decisions.d.ts

@@ -0,0 +1,95 @@
+/**
+ * The decision-provider wire types (the decision-providers spec): a
+ * provider TYPE whose models answer typed questions (noul / choice /
+ * score) over a JSON state, for extensions that need small structured
+ * judgments rather than a chat completion.
+ *
+ * TYPE-ONLY module, with NO imports at all: `JsonValue`/`JsonObject` are
+ * declared locally exactly the way `shared/src/json.ts` mirrors them, so
+ * the shared leaf keeps its zero-import invariant (enforced by
+ * test/views-purity.test.ts). The two `DECISION_MAX_*` constants are
+ * pure VALUES — wire modules carry "types + pure constants".
+ */
+/** A strict-JSON value (local mirror — see shared/src/json.ts). */
+export type DecisionJsonValue = null | boolean | number | string | DecisionJsonValue[] | {
+    [key: string]: DecisionJsonValue;
+};
+/** A strict-JSON object (local mirror — see shared/src/json.ts). */
+export type DecisionJsonObject = {
+    [key: string]: DecisionJsonValue;
+};
+/** The state a decision question is asked over: a string or strict JSON. */
+export type DecisionState = string | DecisionJsonObject | DecisionJsonValue[];
+/** One typed question. Choice needs at least one label; score at least two levels. */
+export type DecisionQuestion = {
+    readonly type: "noul";
+    readonly instructions?: DecisionJsonValue;
+    readonly criteria?: {
+        readonly true?: DecisionJsonValue;
+        readonly false?: DecisionJsonValue;
+    } | null;
+} | {
+    readonly type: "choice";
+    readonly instructions?: DecisionJsonValue;
+    readonly criteria: Readonly<Record<string, DecisionJsonValue | null>>;
+} | {
+    readonly type: "score";
+    readonly instructions?: DecisionJsonValue;
+    readonly criteria: readonly DecisionJsonValue[];
+};
+/** One evaluation: a state plus 1..32 typed questions. */
+export interface DecisionRequest {
+    readonly state: DecisionState;
+    readonly questions: Readonly<Record<string, DecisionQuestion>>;
+}
+/** One answer, matching its question's type; probabilities are in [0, 1]. */
+export type DecisionAnswer = {
+    readonly type: "noul";
+    readonly noul: number;
+} | {
+    readonly type: "choice";
+    readonly choice: string;
+    readonly confidence: number;
+    readonly probabilities: Readonly<Record<string, number>>;
+} | {
+    readonly type: "score";
+    readonly score: number;
+    readonly confidence: number;
+    readonly probabilities: Readonly<Record<string, number>>;
+    readonly legend?: Readonly<Record<string, DecisionJsonValue>>;
+};
+/** The provider's answer set plus optional usage bookkeeping. */
+export interface DecisionAnswers {
+    readonly answers: Readonly<Record<string, DecisionAnswer>>;
+    readonly usage?: {
+        readonly input_tokens: number | null;
+        readonly output_tokens: number | null;
+    };
+    readonly model?: string;
+}
+/** The outcome of one `evaluate` call; NEVER a throw. */
+export type DecisionResult = {
+    readonly ok: true;
+    readonly model: string;
+    readonly answers: Readonly<Record<string, DecisionAnswer>>;
+    readonly usage: {
+        readonly input_tokens: number | null;
+        readonly output_tokens: number | null;
+    };
+    readonly elapsedMs: number;
+} | {
+    readonly ok: false;
+    readonly code: "no_model" | "unknown_model" | "invalid_request" | "over_limits" | "not_configured" | "timeout" | "aborted" | "failed" | "bad_answer";
+    readonly error: string;
+};
+/** A model's declared limits (narrower than the built-in caps win). */
+export interface DecisionLimits {
+    readonly maxQuestions?: number;
+    readonly maxInputBytes?: number;
+    readonly minChoiceOptions?: number;
+    readonly maxScoreLevels?: number;
+}
+/** Built-in cap: at most this many questions per request. */
+export declare const DECISION_MAX_QUESTIONS = 32;
+/** Built-in cap: the JSON state serialized size, in bytes. */
+export declare const DECISION_MAX_BYTES = 65536;

package/node_modules/@sigrun/shared/dist/decisions.js

@@ -0,0 +1,16 @@
+/**
+ * The decision-provider wire types (the decision-providers spec): a
+ * provider TYPE whose models answer typed questions (noul / choice /
+ * score) over a JSON state, for extensions that need small structured
+ * judgments rather than a chat completion.
+ *
+ * TYPE-ONLY module, with NO imports at all: `JsonValue`/`JsonObject` are
+ * declared locally exactly the way `shared/src/json.ts` mirrors them, so
+ * the shared leaf keeps its zero-import invariant (enforced by
+ * test/views-purity.test.ts). The two `DECISION_MAX_*` constants are
+ * pure VALUES — wire modules carry "types + pure constants".
+ */
+/** Built-in cap: at most this many questions per request. */
+export const DECISION_MAX_QUESTIONS = 32;
+/** Built-in cap: the JSON state serialized size, in bytes. */
+export const DECISION_MAX_BYTES = 65_536;

package/node_modules/@sigrun/shared/dist/interactions.d.ts

@@ -54,6 +54,20 @@ export type InteractionRecord = {
      * model-asserted. Absent on the naive single-operator path (no user).
      */
     readonly answeredByUser?: string;
+    /**
+     * Decline affordance (ask-user Task 1, spec §5.2): `true` marks the
+     * record declinable — a human may skip it without answering (the
+     * decline route / `host.declineInteraction`). Absent or omitted means
+     * NOT declinable; `false` fails validation (the flag is `true`-only).
+     */
+    readonly declinable?: true;
+    /**
+     * How the record was declined (ask-user Task 1/2): "button" via the
+     * decline route or host method, "message" via an admitted decline
+     * message. Set only on a `skipped` decline; absent on every other
+     * terminal status.
+     */
+    readonly declinedVia?: "button" | "message";
     /**
      * The interaction body: a block tree (placement `interaction` — a
      * root `form` whose `submit` is the answer). Legacy-shaped bodies

package/node_modules/@sigrun/shared/dist/jobs.d.ts

@@ -53,6 +53,8 @@ export type JobAction = {
 /** A job's declared shape — what every source (api/file/extension) supplies. */
 export type JobSpec = {
     name: string;
+    /** Optional ≤500-char human description, shown in the Jobs view. */
+    description?: string;
     schedule: JobSchedule;
     action: JobAction;
     overlap?: "skip" | "queue";
@@ -68,6 +70,8 @@ export type JobWire = {
     source: "api" | "file" | "extension";
     owner?: string;
     sharing?: Sharing;
+    /** Optional ≤500-char human description, shown in the Jobs view. */
+    description?: string;
     schedule: JobSchedule;
     action: JobAction;
     enabled: boolean;

package/node_modules/@sigrun/shared/dist/settings.d.ts

@@ -163,6 +163,20 @@ export interface ServerSettings {
         readonly workerDeadlineMs?: number;
         readonly queueMax?: number;
     };
+    /**
+     * The published-hook call deadline (knowledge C7): the per-call cap,
+     * mirroring `SIGRUN_PUBLISHED_HOOK_DEADLINE` (env wins). Default
+     * 30000 ms.
+     */
+    readonly publishedHookDeadlineMs?: number;
+    /**
+     * The decision-provider knob (warden Task 6): `SIGRUN_DECISION_TIMEOUT_MS`
+     * — the per-call timeout (default AND cap, default 15000 ms), a
+     * positive integer.
+     */
+    readonly decisions?: {
+        readonly timeoutMs?: number;
+    };
     /** The multi-user execution jail (M1). `mode` and `osUsers` are restart-required. */
     readonly isolation?: {
         /** `SIGRUN_ISOLATION` — auto, always, or off; default auto. */
@@ -406,6 +420,15 @@ export interface SettingsFile {
      * next naming call without a restart.
      */
     readonly namingModel?: string | false;
+    /**
+     * Sigrun: the decision providers' default model (warden Task 6), a
+     * non-empty `provider/model-id` spec validated exactly like
+     * `defaultModel`. Absent = the first model of the first-registered
+     * decision provider. LIVE — the decision registry reads it per
+     * `host.decisions.evaluate` call, so a PATCH reaches the next call
+     * without a restart.
+     */
+    readonly decisionModel?: string;
     /**
      * Sigrun: the env-driven OpenAI-compatible provider's endpoint
      * (ruling 7), applied when `OPENAI_BASE_URL` is absent.
@@ -441,6 +464,15 @@ export interface SettingsFile {
      * `defaultTools`.
      */
     readonly autoEnableCodemode?: boolean;
+    /**
+     * Sigrun: the decision surface's toggles (warden Task 6). `tool`
+     * (default false) gates the core `decision_evaluate` tool — read at
+     * each tool call; a disabled tool returns an error result naming the
+     * setting. LIVE.
+     */
+    readonly decisions?: {
+        readonly tool?: boolean;
+    };
     /**
      * Sigrun: the static boot configuration (see {@link ServerSettings}).
      * Deployment defaults under env — changes require a restart.

package/node_modules/@sigrun/shared/dist/views.d.ts

@@ -339,6 +339,12 @@ export interface InteractionAnswered {
     readonly status: "answered";
     readonly answer: InteractionAnswer;
 }
+/** The response of `POST .../interactions/:callId/decline`. */
+export interface InteractionDeclined {
+    readonly callId: string;
+    readonly status: "skipped";
+    readonly declinedVia: "button";
+}
 /** One ambient surface on the wire (envelope + body + details). */
 export type AmbientWire = AmbientRecord;
 /** The response of `GET /v1/conversations/:id/ambient`. */
@@ -607,6 +613,41 @@ export interface MetaResponse {
             readonly contributor: string;
         }[];
     };
+    /**
+     * The published-hook registry (knowledge C7): one row per OWNED hook
+     * name — `provider` is the owner slug, `shadowed` the losing
+     * providers (configured losers before built-in losers). Ownership is
+     * first-listed over `extensions[]`, configured before built-ins;
+     * empty when nothing published.
+     */
+    readonly publishedHooks: readonly {
+        readonly name: string;
+        readonly provider: string;
+        readonly shadowed: readonly string[];
+    }[];
+    /**
+     * The decision-provider seam projection (warden Task 7): the
+     * registry's providers (id/label/extension/models/status), the
+     * resolved default model (the live `decisionModel` setting, else the
+     * first model of the first-registered provider), and the boot-merge
+     * collision record. Empty arrays and no default on the no-provider
+     * boot.
+     */
+    readonly decisions: {
+        readonly providers: readonly {
+            readonly id: string;
+            readonly label?: string;
+            readonly extension: string;
+            readonly models: readonly string[];
+            readonly status: AuthStatus;
+        }[];
+        readonly default?: string;
+        readonly collisions: readonly {
+            readonly id: string;
+            readonly winner: string;
+            readonly losers: readonly string[];
+        }[];
+    };
 }
 /**
  * Provider auth readiness statuses (Task 6, spec §6.4 + provider plugins
@@ -633,6 +674,18 @@ export interface AuthCheckProvider {
     readonly status: AuthStatus;
     /** How many models the provider currently serves (best-effort count). */
     readonly models: number;
+    /**
+     * Warden Task 7: `"chat"` (a chat-catalog provider) or `"decision"` (a
+     * decision provider from the warden seam). Absent = `"chat"` (older
+     * servers never carried the field); a chat and a decision provider
+     * sharing an id stay SEPARATE entries, one of each kind.
+     */
+    readonly kind?: "chat" | "decision";
+    /**
+     * The decision provider's bare model ids (warden Task 7) — present
+     * only on `kind: "decision"` entries (`models` is their count).
+     */
+    readonly modelIds?: readonly string[];
     /** The owning contributor's name; absent for the env-degenerate provider. */
     readonly owner?: string;
     readonly detail?: string;
@@ -736,6 +789,11 @@ export interface ExtensionSurfaceInfo {
      *  answer with `ops` and NO `data` — channels fall back to a full
      *  fetch (ops folding is U1). Absent → per-instance data. */
     readonly sharedData?: boolean;
+    /** The panel opts in to per-conversation attachment: channels attach
+     *  it with `params: { conversationId }` of the OPEN conversation. The
+     *  id is client-supplied — the extension must check access. Absent
+     *  (the sparse rule) → the panel is not conversation-scoped. */
+    readonly perConversation?: true;
 }
 /** The `GET /v1/extensions` payload (spec §7.7). */
 export interface ExtensionsResponse {

package/node_modules/@sigrun/shared/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sigrun/shared",
-	"version": "0.8.0",
+	"version": "0.10.0",
 	"description": "sigrun shared leaf package \u2014 theme tokens, turn/conversation shaping, and the channel wire types (pure leaf, zero dependencies)",
 	"type": "module",
 	"exports": {
@@ -72,6 +72,10 @@
 			"types": "./dist/jobs.d.ts",
 			"default": "./dist/jobs.js"
 		},
+		"./decisions": {
+			"types": "./dist/decisions.d.ts",
+			"default": "./dist/decisions.js"
+		},
 		"./blocks": {
 			"types": "./dist/blocks/index.d.ts",
 			"default": "./dist/blocks/index.js"
@@ -105,4 +109,4 @@
 		"access": "public",
 		"provenance": true
 	}
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sigrun/sigrun",
-	"version": "0.8.0",
+	"version": "0.10.0",
 	"description": "Self-hosted, multi-user personal-assistant server",
 	"type": "module",
 	"exports": {
@@ -45,12 +45,12 @@
 		"@earendil-works/pi-tui": "^1.3.0",
 		"@fastify/static": "^10.1.7",
 		"@sigrun/ext-codemode": "0.1.2",
-		"@sigrun/ext-curator": "0.3.0",
-		"@sigrun/ext-gateway": "0.1.16",
-		"@sigrun/ext-mcp": "0.2.2",
+		"@sigrun/ext-curator": "0.3.2",
+		"@sigrun/ext-gateway": "0.1.19",
+		"@sigrun/ext-mcp": "0.2.3",
 		"@sigrun/ext-tool-search": "0.1.2",
 		"@sigrun/oauth": "0.1.1",
-		"@sigrun/shared": "0.8.0",
+		"@sigrun/shared": "0.10.0",
 		"croner": "^10.0.1",
 		"fastify": "^5.12.7",
 		"semver": "^7.8.5",
@@ -61,9 +61,9 @@
 		"@sigrun/shared"
 	],
 	"optionalDependencies": {
-		"@sigrun/sandbox-linux-arm64": "0.8.0",
-		"@sigrun/sandbox-linux-x64": "0.8.0",
-		"@sigrun/tui": "0.8.0"
+		"@sigrun/sandbox-linux-arm64": "0.10.0",
+		"@sigrun/sandbox-linux-x64": "0.10.0",
+		"@sigrun/tui": "0.10.0"
 	},
 	"devDependencies": {
 		"@sigrun/memory-markdown": "file:../sigrun-memory-markdown",