@sigrun/sigrun 0.5.0 → 0.6.0

package/dist/jobs/index.js

@@ -28,6 +28,7 @@ import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
 import { JobDoc, listRevisions, listRuns, pruneHistory, readJob, scanJobs, writeJobChange, } from "./docs.js";
 import { fireJob } from "./fire.js";
 import { reconcileJobs, } from "./reconcile.js";
+import { jobStateDir, removeJobState } from "./state-dir.js";
 import { specHash } from "./spec.js";
 /** Thrown when an API write targets a `file:`/`ext:` job id (409 `job_declared`). */
 export class JobDeclaredError extends Error {
@@ -53,13 +54,15 @@ function historyLimits(settings) {
 }
 /** The wire row of a record (access left for the caller: the ROUTE
  *  computes it per principal; the raw row carries the neutral default).
- *  Exported for boot's `job.changed` publication (W4 Task 4). */
-export function jobWireOf(id, record) {
+ *  Exported for boot's `job.changed` publication (W4 Task 4). The
+ *  effective owner is resolved by the caller; the stored record and its
+ *  spec hash remain untouched (spec §6.5). */
+export function jobWireOf(id, record, owner) {
     return {
         id,
         name: record.spec.name,
         source: record.source,
-        ...(record.owner === undefined ? {} : { owner: record.owner }),
+        ...(owner === undefined ? {} : { owner }),
         ...(record.sharing === undefined
             ? {}
             : { sharing: JSON.parse(JSON.stringify(record.sharing)) }),
@@ -82,6 +85,17 @@ export function jobWireOf(id, record) {
 export function createJobsService(deps) {
     const ctx = BACKGROUND_CONTEXT;
     const limits = () => historyLimits(deps.settings);
+    const wireOf = (id, record) => jobWireOf(id, record, deps.effectiveOwner(record.owner));
+    const stateRoot = (owner) => deps.jobsRoot?.(owner);
+    const removeStateBestEffort = async (root, id) => {
+        try {
+            await removeJobState(root, id);
+        }
+        catch (error) {
+            const path = root === undefined ? id : jobStateDir(root, id);
+            console.warn(`jobs: could not remove job state ${path}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    };
     // `job.changed` observation (W4 Task 4): ONE commit subscription over
     // the `sigrun.job` family invokes the injected hook after EVERY record
     // change — the service's own API writes, the executor's status patches
@@ -114,15 +128,16 @@ export function createJobsService(deps) {
         runtime: deps.runtime,
         rootId: deps.rootId,
         sources: deps.sources,
+        ...(deps.jobsRoot === undefined ? {} : { jobsRoot: deps.jobsRoot }),
     }, ctx);
     return {
         async list() {
             const records = await scanJobs(deps.storage, ctx);
-            return records.map(({ id, record }) => jobWireOf(id, record));
+            return records.map(({ id, record }) => wireOf(id, record));
         },
         async get(id) {
             const record = await readJob(deps.harness, id, ctx);
-            return record === undefined ? undefined : jobWireOf(id, record);
+            return record === undefined ? undefined : wireOf(id, record);
         },
         async createApi(spec, owner) {
             const id = `api:${crypto.randomUUID()}`;
@@ -150,7 +165,7 @@ export function createJobsService(deps) {
             const record = await readJob(deps.harness, id, ctx);
             if (record === undefined)
                 throw new JobNotFoundError(id);
-            return jobWireOf(id, record);
+            return wireOf(id, record);
         },
         async updateApi(id, patch, changedBy) {
             const prior = await readJob(deps.harness, id, ctx);
@@ -191,7 +206,7 @@ export function createJobsService(deps) {
             const record = await readJob(deps.harness, id, ctx);
             if (record === undefined)
                 throw new JobNotFoundError(id);
-            return jobWireOf(id, record);
+            return wireOf(id, record);
         },
         async runs(id, limit) {
             return await listRuns(deps.storage, id, Math.max(0, limit), ctx);
@@ -205,14 +220,26 @@ export function createJobsService(deps) {
                 throw new JobNotFoundError(id);
             if (prior.source !== "api")
                 throw new JobDeclaredError(id);
+            // Resolve against the prior owner: the retiring commit removes the
+            // record, and state cleanup must not fall back to another user.
+            const root = stateRoot(prior.owner);
             const nowIso = new Date(deps.runtime.now()).toISOString();
             await deps.harness.commit(async (tx) => {
                 // The final `enabled:false` revision, then the retire.
                 await writeJobChange(tx, id, { ...prior, enabled: false }, changedBy, nowIso);
                 await tx.retireDoc(JobDoc, id);
             }, ctx);
+            await removeStateBestEffort(root, id);
             await reconcileOne();
         },
+        async resetState(id) {
+            const record = await readJob(deps.harness, id, ctx);
+            if (record === undefined)
+                throw new JobNotFoundError(id);
+            // Unlike delete/transfer/reconcile, an explicit reset surfaces I/O
+            // failure to its caller; it never rewrites or retires the job.
+            await removeJobState(stateRoot(record.owner), id);
+        },
         async runNow(id) {
             // ONE clock reading: the manual fire key and the run's fireAt must
             // agree — the settle path re-derives the run-record key from

package/dist/jobs/reconcile.js

@@ -38,6 +38,7 @@
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
 import { JobDoc, patchJob, scanJobs, writeJobChange, } from "./docs.js";
 import { nextFireAt } from "./schedule.js";
+import { jobStateDir, removeJobState } from "./state-dir.js";
 import { specHash } from "./spec.js";
 import { createScheduleTask } from "./task.js";
 const SCAN_PAGE = 500;
@@ -153,6 +154,14 @@ export async function reconcileJobs(deps, ctx = BACKGROUND_CONTEXT) {
         if (declaredIds.has(id))
             continue;
         await retireRecord(deps.harness, id, record, nowIso, ctx);
+        const root = deps.jobsRoot?.(record.owner);
+        try {
+            await removeJobState(root, id);
+        }
+        catch (error) {
+            const path = root === undefined ? id : jobStateDir(root, id);
+            console.warn(`jobs: could not remove retired job state ${path}: ${error instanceof Error ? error.message : String(error)}`);
+        }
     }
     // ── Pass 2: records → tasks ─────────────────────────────────────
     const after = new Map();

package/dist/jobs/state-dir.js

@@ -0,0 +1,16 @@
+/** Resolve and remove one job's on-disk state directory. */
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+/** The complete job id is encoded into one path segment. */
+export function jobStateDir(root, jobId) {
+    return join(root, encodeURIComponent(jobId));
+}
+/**
+ * Remove job state, or do nothing when the selected owner has no jobs root.
+ * Deletion failures reject so each job operation can apply its own policy.
+ */
+export async function removeJobState(root, jobId) {
+    if (root === undefined)
+        return;
+    await rm(jobStateDir(root, jobId), { recursive: true, force: true });
+}

package/dist/jobs/transfer.js

@@ -17,8 +17,10 @@
  * ownerless until the source is edited — spec §8.3's posture).
  */
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { join } from "node:path";
 import { registerOwnershipParticipant } from "../server/ownership.js";
 import { scanJobs, writeJobChange } from "./docs.js";
+import { jobStateDir } from "./state-dir.js";
 import { specHash } from "./spec.js";
 /**
  * Register the jobs transfer participant on `ctx` (createServer calls
@@ -36,6 +38,18 @@ export function registerJobsOwnershipParticipant(ctx) {
                 continue;
             if (record.owner !== from)
                 continue;
+            try {
+                // Before the owner rewrite: resetState resolves the old owner's
+                // root. The recipient's folder is deliberately never created.
+                await jobs.resetState(id);
+            }
+            catch (error) {
+                // Directory-user api jobs use their managed user area. (OS-user
+                // jobs cannot enter this transfer path — user deletion refuses
+                // osUser workspaces before any participant runs.)
+                const root = join(ctx.managedPaths.userAreas(from), "jobs");
+                console.warn(`jobs: could not remove transferred job state ${jobStateDir(root, id)}: ${error instanceof Error ? error.message : String(error)}`);
+            }
             const spec = { ...record.spec, owner: to };
             const next = {
                 ...record,

package/dist/sandbox/policy.js

@@ -162,21 +162,22 @@ export function buildUserPolicy(record, ctx) {
         };
     }
     // EVERY per-user path passes the same validator before entering policy:
-    // stored workspace/grants via revalidate, and workspace/home again below.
+    // stored workspace/grants via revalidate, and workspace/home/jobs again below.
     // An osAccount home must validate BEFORE any directory is created.
     // tmp is the ONE sanctioned stateDir exception: it is derived only from
     // stateDir/sandbox/<user>/tmp and never silently routed around validation.
     const userArea = ctx.managed.userAreas(record.user);
     const requestedWorkspace = record.workspace ?? ctx.osAccount?.home ?? join(userArea, "workspace");
     const requestedHome = ctx.osAccount?.home ?? join(userArea, "home");
+    const requestedJobs = join(userArea, "jobs");
     if (ctx.osAccount !== undefined) {
         const validation = validateUserPath(requestedHome, record, ctx.managed);
         if (!validation.ok)
             return invalidReason(requestedHome, validation.reason);
     }
     const tmp = join(ctx.managed.roots.stateDir, "sandbox", record.user, "tmp");
-    for (const path of [requestedWorkspace, requestedHome, tmp]) {
-        if (ctx.osAccount !== undefined && path === tmp)
+    for (const path of [requestedWorkspace, requestedHome, tmp, requestedJobs]) {
+        if (ctx.osAccount !== undefined && (path === tmp || path === requestedJobs))
             continue;
         mkdirSync(path, { recursive: true, mode: 0o700 });
     }
@@ -197,6 +198,12 @@ export function buildUserPolicy(record, ctx) {
     const homeValidation = validateUserPath(requestedHome, record, ctx.managed);
     if (!homeValidation.ok)
         return invalidReason(requestedHome, homeValidation.reason);
+    const jobsValidation = ctx.osAccount === undefined
+        ? validateUserPath(requestedJobs, record, ctx.managed)
+        : undefined;
+    if (jobsValidation !== undefined && !jobsValidation.ok) {
+        return invalidReason(requestedJobs, jobsValidation.reason);
+    }
     const realTmp = canonical(tmp) ?? (ctx.osAccount === undefined
         ? undefined
         : resolve(tmp));
@@ -204,6 +211,7 @@ export function buildUserPolicy(record, ctx) {
         return invalidReason(tmp, "path cannot be resolved");
     const realWorkspace = workspaceValidation.realpath;
     const realHome = homeValidation.realpath;
+    const realJobs = jobsValidation?.realpath;
     // A source checkout that has ever been built has BOTH src/ and dist/;
     // defaultModuleTrees picks one while the worker entry may use the other
     // (dist worker.js when present, src worker.ts via tsx otherwise).
@@ -227,9 +235,10 @@ export function buildUserPolicy(record, ctx) {
         ...grants.flatMap((grant) => (grant.access === "rw" ? [grant.path] : [])),
         realHome,
         realTmp,
+        ...(realJobs === undefined ? [] : [realJobs]),
         // Device creation belongs to rw, but the selected devices' ordinary
         // read/write I/O survives a read-only Landlock rule. rw stays empty
-        // except for workspace/home/tmp/grants so /dev/shm remains denied.
+        // except for workspace/home/jobs/tmp/grants so /dev/shm remains denied.
     ]);
     const ro = sortedUnique([
         "/dev",

package/dist/serve.js

@@ -175,9 +175,11 @@ export async function serve(env, options) {
     const envModel = env.SIGRUN_DEFAULT_MODEL?.trim() || env.SIGRUN_MODEL?.trim() || undefined;
     const settingsStore = new SettingsStore({ dir: defaultSettingsDir() });
     settingsStore.bootstrap(envServerSection(env), {
-        extensions: env.SIGRUN_EXTENSIONS?.trim() === undefined
-            ? undefined
-            : envConfig.extensions,
+        // E8 smoke: SIGRUN_EXTENSIONS without any model env crashed boot —
+        // envConfig is only resolved when a model env is set (see envHasModel
+        // above), so envConfig!.extensions dereferenced undefined here.
+        // parseExtensionList is the env-side source of truth; use it directly.
+        extensions: parseExtensionList(env.SIGRUN_EXTENSIONS),
         defaultModel: envModel === undefined
             ? undefined
             : `${envConfig.models.provider}/${envConfig.models.modelId}`,

package/dist/server/conversation-ops.js

@@ -146,6 +146,17 @@ export async function createConversationOp(ctx, input = {}) {
     if (input.name !== undefined && typeof input.name !== "string") {
         throw new ConversationOpError({ error: "invalid_field", field: "name" });
     }
+    if (input.job !== undefined) {
+        // Resolve the live job (and therefore its EFFECTIVE owner) before the
+        // createConversation table write or the session-meta commit. An absent
+        // requested owner and an absent effective owner are an exact match.
+        const job = typeof input.job === "string"
+            ? await opened.jobs.get(input.job)
+            : undefined;
+        if (job === undefined || input.owner !== job.owner) {
+            throw new ConversationOpError({ error: "invalid_field", field: "job" });
+        }
+    }
     if (input.source !== undefined && typeof input.source !== "string") {
         throw new ConversationOpError({ error: "invalid_field", field: "source" });
     }
@@ -227,6 +238,8 @@ export async function createConversationOp(ctx, input = {}) {
         }
         if (input.name !== undefined)
             draft.name = input.name;
+        if (input.job !== undefined)
+            draft.jobId = input.job;
         if (input.source !== undefined)
             draft.source = input.source;
         await opened.rewriteUserSelection(tx, conversation.id, undefined, input.owner);

package/dist/server/host-bridge.js

@@ -22,6 +22,7 @@ import { userWire } from "./routes/users.js";
 import { accessPrincipalOf } from "./auth/access-principal.js";
 import { abortOp, compactOp, configureOp, ConversationOpError, createConversationOp, forkOp, listConversationsOp, patchMetaOp, readFileOp, readMetaOp, submitOp, uploadOp, } from "./conversation-ops.js";
 import { listModels } from "./helpers.js";
+import { notifyExtension } from "./notifications.js";
 import { SessionMetaDoc } from "./session-meta.js";
 import { accountLinkWire, serializeConversationView } from "./views.js";
 /**
@@ -108,6 +109,15 @@ export function createHostBridge(ctx) {
                 await conversationOf(id);
                 return await readMetaOp(opened, id);
             },
+            async entries(id, query, limit, cursor) {
+                const conversation = await conversationOf(id);
+                return await conversation.entries(query, limit, cursor, BACKGROUND_CONTEXT);
+            },
+            async entry(id, entryId) {
+                const conversation = await conversationOf(id);
+                const page = await conversation.entries({ minEntryId: entryId, maxEntryId: entryId }, 1, undefined, BACKGROUND_CONTEXT);
+                return page.items[0];
+            },
             // Gateway C4a: the remaining conversation ops, each the SAME op
             // its HTTP route runs — resolved through conversationOf (unknown id
             // → the bridge's loud `conversation <id> not found`).
@@ -170,6 +180,20 @@ export function createHostBridge(ctx) {
                 return await readFileOp(ctx, conversation, path);
             },
         },
+        jobs: {
+            async get(id) {
+                const job = await opened.jobs.get(id);
+                if (job === undefined)
+                    return undefined;
+                return {
+                    id: job.id,
+                    name: job.name,
+                    ...(job.owner === undefined ? {} : { owner: job.owner }),
+                    enabled: job.enabled,
+                    state: job.state,
+                };
+            },
+        },
         users: {
             // The directory in wire form (emails are admin material; the
             // bridge is in-process server code, the same trust as the
@@ -279,6 +303,7 @@ export function createHostBridge(ctx) {
                     : { notice: result.notice };
             },
         },
+        notify: (slug, input) => notifyExtension(ctx, slug, input),
         surfaces: {
             // UI-blocks U3 Task 4 (spec §7.3): the same bumpRev the actions
             // route takes — the rev advance and the hub event are one step.

package/dist/server/notifications.js

@@ -40,6 +40,29 @@ import { SessionMetaDoc } from "./session-meta.js";
 function displayName(meta, id) {
     return meta?.name ?? meta?.autoName ?? `Conversation ${id}`;
 }
+/** Collect every loaded notifier with its contributing extension's host. */
+export function collectTargets(ctx) {
+    const targets = [];
+    for (const binding of ctx.opened.notifierBindings) {
+        // The Task 2 ext-route host semantics: the captured seam host,
+        // cast across the not-yet-bridged members.
+        const host = ctx.opened.seamHosts.get(binding.extension);
+        for (const notifier of binding.notifiers) {
+            targets.push({ extension: binding.extension, notifier, host });
+        }
+    }
+    return targets;
+}
+/** Enqueue one per-recipient event through every notifier (never awaited). */
+export function deliverEvent(ctx, targets, event) {
+    for (const target of targets) {
+        // Fire-and-forget per transport call: one notifier's failure or
+        // hang neither blocks nor loses the others' deliveries.
+        void ctx.opened.eventBus.runBounded(`notifier ${target.extension}.${target.notifier.name}`, () => target.notifier.notify(event, {
+            host: target.host,
+        }));
+    }
+}
 /**
  * Start the notifications surface. Returns its unsubscribe (the server
  * never calls it today — the surface rides the process lifetime — but
@@ -48,15 +71,7 @@ function displayName(meta, id) {
  */
 export function startNotifications(ctx) {
     const { opened, config } = ctx;
-    const targets = [];
-    for (const binding of opened.notifierBindings) {
-        // The Task 2 ext-route host semantics: the captured seam host,
-        // cast across the not-yet-bridged members.
-        const host = opened.seamHosts.get(binding.extension);
-        for (const notifier of binding.notifiers) {
-            targets.push({ extension: binding.extension, notifier, host });
-        }
-    }
+    const targets = collectTargets(ctx);
     if (targets.length === 0)
         return () => { };
     const bus = opened.eventBus;
@@ -83,13 +98,7 @@ export function startNotifications(ctx) {
                 // the conditional spread keeps the wire shape exact).
                 ...(base.outcome === undefined ? {} : { outcome: base.outcome }),
             };
-            for (const target of targets) {
-                // Fire-and-forget per transport call: one notifier's failure or
-                // hang neither blocks nor loses the others' deliveries.
-                void bus.runBounded(`notifier ${target.extension}.${target.notifier.name}`, () => target.notifier.notify(event, {
-                    host: target.host,
-                }));
-            }
+            deliverEvent(ctx, targets, event);
         }
     };
     /** One conversation's live SessionMeta (undefined on absence or read failure, logged). */
@@ -210,3 +219,80 @@ export function startNotifications(ctx) {
     });
     return unsubscribe;
 }
+/**
+ * Validate and enqueue one extension notice. The caller's promise resolves
+ * after validation and enqueueing, not after any transport has delivered.
+ */
+export async function notifyExtension(ctx, slug, input) {
+    const users = ctx.opened.identity.users;
+    if (users.isClaimed()) {
+        if (input.user === undefined) {
+            throw new Error("notification user is required when the directory is non-empty");
+        }
+        if (users.get(input.user) === undefined) {
+            throw new Error(`unknown user "${input.user}"`);
+        }
+    }
+    if (typeof input.title !== "string" ||
+        input.title.length < 1 ||
+        input.title.length > 200) {
+        throw new Error("notification title must be 1..200 characters");
+    }
+    if (typeof input.body !== "string" ||
+        input.body.length > 2000) {
+        throw new Error("notification body must be 0..2000 characters");
+    }
+    if (!/^[a-z0-9.-]{1,64}$/.test(input.kind)) {
+        throw new Error("notification kind must be 1..64 characters from [a-z0-9.-]");
+    }
+    if (input.target !== undefined) {
+        if (typeof input.target !== "object" || input.target === null || Array.isArray(input.target)) {
+            throw new Error("notification target must be an object");
+        }
+        const hasView = "view" in input.target;
+        const hasConversation = "conversation" in input.target;
+        if (hasView === hasConversation) {
+            throw new Error("notification target must have exactly one of view or conversation");
+        }
+        if ((hasView && typeof input.target.view !== "string") ||
+            (hasConversation && typeof input.target.conversation !== "number")) {
+            throw new Error("notification target requires a string view or a number conversation");
+        }
+    }
+    let conversationId;
+    let url;
+    if (input.target !== undefined && "view" in input.target) {
+        const view = input.target.view;
+        const binding = ctx.opened.extensionSurfaces.find((candidate) => candidate.extension === slug);
+        const declared = binding?.defs.some((def) => def.placement === "view" && def.id === view);
+        if (declared !== true) {
+            throw new Error(`notification view "${view}" was not declared by extension "${slug}"`);
+        }
+        if (ctx.config.publicUrl !== undefined) {
+            const base = `${ctx.config.publicUrl}/#/ext/${encodeURIComponent(slug)}/` +
+                encodeURIComponent(view);
+            const params = input.target.params ?? {};
+            url = Object.keys(params).length === 0
+                ? base
+                : `${base}?params=${encodeURIComponent(JSON.stringify(params))}`;
+        }
+    }
+    else {
+        conversationId = input.target?.conversation;
+        if (conversationId !== undefined && ctx.config.publicUrl !== undefined) {
+            url = `${ctx.config.publicUrl}/#/c/${conversationId}`;
+        }
+    }
+    const event = {
+        type: "extension",
+        extension: slug,
+        kind: input.kind,
+        conversationId,
+        jobId: undefined,
+        user: input.user,
+        title: input.title,
+        body: input.body,
+        ...(url === undefined ? {} : { url }),
+    };
+    deliverEvent(ctx, collectTargets(ctx), event);
+}

package/dist/server/routes/jobs.js

@@ -212,6 +212,37 @@ export function registerJobRoutes(app, ctx) {
             return await domainError(reply, error);
         }
     });
+    // POST /v1/jobs/:id/state/reset — write access; any live job source.
+    // The job's definition and history stay intact; only its persistent
+    // state folder is removed. Unlike delete/transfer/reconcile cleanup,
+    // an explicit reset surfaces a failed removal to the caller.
+    app.post("/v1/jobs/:id/state/reset", async (request, reply) => {
+        const { id } = request.params;
+        const wire = await jobs.get(id);
+        if (wire === undefined) {
+            return await deny(reply, "job_not_found");
+        }
+        const access = accessOf(accessPrincipal(request), resourceOf(wire));
+        if (access === "none") {
+            return await deny(reply, "job_not_found");
+        }
+        if (access === "read") {
+            return await deny(reply, "forbidden");
+        }
+        try {
+            await jobs.resetState(id);
+            return await reply.code(204).send();
+        }
+        catch (error) {
+            if (error instanceof JobNotFoundError) {
+                return await deny(reply, "job_not_found");
+            }
+            return await reply.code(500).send({
+                error: "state_reset_failed",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
     // POST /v1/jobs/:id/run — write access; fires now (overlap honored).
     // A LIVE record is required (like PATCH/DELETE): a retired job's
     // revision never satisfies run-now — 404, never fireJob's blocked-200

package/dist/settings/core-sections.js

@@ -496,6 +496,15 @@ export const CORE_SETTINGS_SECTIONS = [
                                 help: "The built-in tool-search extension — applies at restart",
                                 apply: applyOf("builtinExtensions.toolSearch"),
                             },
+                            {
+                                type: "toggle",
+                                // Absent means ON (the built-in set defaults enabled).
+                                default: true,
+                                name: "builtinExtensions.gateway",
+                                label: "Gateway",
+                                help: "The built-in channel gateway engine — applies at restart",
+                                apply: applyOf("builtinExtensions.gateway"),
+                            },
                             {
                                 type: "toggle",
                                 default: true,

package/dist/settings/registry.js

@@ -169,6 +169,12 @@ export const CORE_SETTING_KEYS = [
         section: "extensions",
         reason: "the built-in set resolves at boot (a disabled built-in never loads)",
     },
+    {
+        key: "builtinExtensions.gateway",
+        apply: "restart",
+        section: "extensions",
+        reason: "the built-in set resolves at boot (a disabled built-in never loads)",
+    },
     {
         key: "builtinExtensions.oauth",
         apply: "restart",

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

@@ -5,6 +5,9 @@ All notable changes to this project will be documented in this file.
 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.6.0] - 2026-11-02
+
+Version-companion release for sigrun 0.6.0 (no shared changes).
 ## [0.5.0] - 2026-11-02
 
 Version-companion release for sigrun 0.5.0 (no shared changes).

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

@@ -1,6 +1,6 @@
 {
 	"name": "@sigrun/shared",
-	"version": "0.5.0",
+	"version": "0.6.0",
 	"description": "sigrun shared leaf package \u2014 theme tokens, turn/conversation shaping, and the channel wire types (pure leaf, zero dependencies)",
 	"type": "module",
 	"exports": {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sigrun/sigrun",
-	"version": "0.5.0",
+	"version": "0.6.0",
 	"description": "Self-hosted, multi-user personal-assistant server",
 	"type": "module",
 	"exports": {
@@ -46,11 +46,11 @@
 		"@fastify/static": "^10.1.7",
 		"@sigrun/ext-codemode": "0.1.2",
 		"@sigrun/ext-curator": "0.1.0",
-		"@sigrun/ext-gateway": "0.1.9",
+		"@sigrun/ext-gateway": "0.1.10",
 		"@sigrun/ext-mcp": "0.2.2",
 		"@sigrun/ext-tool-search": "0.1.2",
 		"@sigrun/oauth": "0.1.1",
-		"@sigrun/shared": "0.5.0",
+		"@sigrun/shared": "0.6.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.5.0",
-		"@sigrun/sandbox-linux-x64": "0.5.0",
-		"@sigrun/tui": "0.5.0"
+		"@sigrun/sandbox-linux-arm64": "0.6.0",
+		"@sigrun/sandbox-linux-x64": "0.6.0",
+		"@sigrun/tui": "0.6.0"
 	},
 	"devDependencies": {
 		"@sigrun/memory-markdown": "file:../sigrun-memory-markdown",