@sigrun/sigrun 0.1.6 → 0.2.1

package/dist/settings/pending.js

@@ -0,0 +1,181 @@
+/**
+ * The pending-restart derivation (UI-blocks U4 Task 1, spec §13.2): the
+ * server keeps a BOOT SNAPSHOT of every `restart` key's stored value,
+ * taken once after settings load and before listen (openHarness is
+ * pre-listen by construction). `pendingRestart` is the diff: the
+ * restart keys whose CURRENT stored value differs from the snapshot —
+ * so patching a key BACK to its boot value removes it (Review Focus 2:
+ * the callout disappears without a restart).
+ *
+ * Also here: the WRITE classification. A PATCH body names top-level or
+ * `server.*` sub-keys; `classifyPatch` expands those to the flattened
+ * registry paths the patch TOUCHED (a `server: {port: 1}` patch touches
+ * `server.port` only) and splits them into `applied` (live) and
+ * `pending` (restart) per the registry.
+ */
+import { DEFAULT_PROVIDER_REFRESH_MINUTES } from "../config.js";
+import { CORE_SETTING_KEYS, applyOf } from "./registry.js";
+/**
+ * The sub-object keys a PATCH merges per-key (matching the store's
+ * update() sub-merge grammar). A patch naming one of these top-level
+ * keys with an object value touches only the SUB-keys present.
+ */
+const SUB_MERGED = new Set([
+    "retry",
+    "stream",
+    "perModelThinking",
+    "defaultProvider",
+    "skills",
+    "jobHistory",
+    "builtinExtensions",
+    "notifications",
+]);
+/**
+ * Expand one PATCH body to the flattened registry paths it touches.
+ * Top-level scalars map 1:1; `server` walks its nested sections; the
+ * other sub-merged objects expand their present sub-keys (a `null`
+ * sub-value clears exactly that key). Unknown paths are kept verbatim
+ * (validation rejects them before this runs, so they never surface —
+ * but keeping them makes the classification total, never lossy).
+ */
+export function touchedKeys(patch) {
+    const out = [];
+    for (const [key, value] of Object.entries(patch)) {
+        if (key === "server") {
+            if (typeof value !== "object" || value === null) {
+                out.push("server");
+                continue;
+            }
+            for (const [serverKey, serverValue] of Object.entries(value)) {
+                const base = `server.${serverKey}`;
+                if ((serverKey === "webui" ||
+                    serverKey === "compaction" ||
+                    serverKey === "memorySeam" ||
+                    serverKey === "providers" ||
+                    serverKey === "backup") &&
+                    typeof serverValue === "object" &&
+                    serverValue !== null) {
+                    for (const sub of Object.keys(serverValue)) {
+                        out.push(`${base}.${sub}`);
+                    }
+                    continue;
+                }
+                if (serverKey === "auth" && typeof serverValue === "object" && serverValue !== null) {
+                    for (const [authKey, authValue] of Object.entries(serverValue)) {
+                        if (authKey === "proxy" &&
+                            typeof authValue === "object" &&
+                            authValue !== null) {
+                            for (const proxyKey of Object.keys(authValue)) {
+                                out.push(`server.auth.proxy.${proxyKey}`);
+                            }
+                            continue;
+                        }
+                        out.push(`server.auth.${authKey}`);
+                    }
+                    continue;
+                }
+                if (serverKey === "metrics" && typeof serverValue === "object" && serverValue !== null) {
+                    for (const sub of Object.keys(serverValue)) {
+                        out.push(`${base}.${sub}`);
+                    }
+                    continue;
+                }
+                out.push(base);
+            }
+            continue;
+        }
+        if (SUB_MERGED.has(key) && typeof value === "object" && value !== null) {
+            for (const sub of Object.keys(value)) {
+                out.push(`${key}.${sub}`);
+            }
+            continue;
+        }
+        out.push(key);
+    }
+    return out;
+}
+/**
+ * Classify a write over the registry: which touched keys are live
+ * (`applied`) and which restart (`pending`). A key with no registry
+ * entry classifies as restart (the conservative default).
+ */
+export function classifyPatch(patch) {
+    const keys = touchedKeys(patch);
+    const applied = [];
+    const pending = [];
+    for (const key of keys) {
+        if (applyOf(key) === "live")
+            applied.push(key);
+        else
+            pending.push(key);
+    }
+    return { applied, pending, keys };
+}
+/** Canonical JSON of one value (object keys sorted, stable). */
+function canonical(value) {
+    return JSON.stringify(value, (_key, v) => typeof v === "object" && v !== null && !Array.isArray(v)
+        ? Object.fromEntries(Object.entries(v).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0))
+        : v);
+}
+/**
+ * Take the boot snapshot: read the restart keys' values from the
+ * CURRENT settings file. Called ONCE per boot, after the settings load
+ * validates and before listen.
+ */
+export function snapshotRestartKeys(file) {
+    const snapshot = new Map();
+    for (const entry of CORE_SETTING_KEYS) {
+        if (entry.apply !== "restart")
+            continue;
+        snapshot.set(entry.key, canonicalAt(file, entry.key));
+    }
+    return snapshot;
+}
+/**
+ * The pending-restart diff: restart keys whose stored value differs
+ * from the boot snapshot. Registry order (stable, matches the audit).
+ */
+export function pendingRestart(file, snapshot) {
+    const pending = [];
+    for (const entry of CORE_SETTING_KEYS) {
+        if (entry.apply !== "restart")
+            continue;
+        if (canonicalAt(file, entry.key) !== snapshot.get(entry.key)) {
+            pending.push(entry.key);
+        }
+    }
+    return pending;
+}
+/**
+ * The CANONICAL JSON at one flattened dotted path: object keys
+ * sorted (stable), `"undefined"` at any missing level — the exact
+ * cell form the snapshot map stores, so the diff is one string
+ * comparison per key (the per-key value shape is the store's
+ * validation domain, never re-parsed here).
+ */
+function canonicalAt(file, path) {
+    let node = file;
+    for (const key of path.split(".")) {
+        if (typeof node !== "object" || node === null) {
+            return canonical(undefined);
+        }
+        node = node[key];
+    }
+    return canonical(node);
+}
+/**
+ * Resolve the provider refresh cadence ENV-OVER-FILE (U4 §13.1's
+ * re-arm): `SIGRUN_PROVIDER_REFRESH_MINUTES` when set, else the fresh
+ * file value, else the code default — exactly `loadConfig`'s
+ * resolution for the same key, read live for the scheduler re-arm.
+ */
+export function resolveRefreshMinutes(env, file) {
+    const fromEnv = env.SIGRUN_PROVIDER_REFRESH_MINUTES;
+    if (fromEnv !== undefined && fromEnv !== "") {
+        const parsed = Number(fromEnv);
+        if (Number.isInteger(parsed) && parsed >= 0)
+            return parsed;
+    }
+    return (file.read().server?.providers?.refreshIntervalMinutes ??
+        DEFAULT_PROVIDER_REFRESH_MINUTES);
+}

package/dist/settings/registry.js

@@ -0,0 +1,453 @@
+/**
+ * The core settings key registry (UI-blocks U4 Task 1, spec §13.1,
+ * ruling 18): ONE entry per key of `SettingsFile` (flattened dotted
+ * paths for nested sections) declaring HOW the setting applies —
+ *
+ * - `live`: the value is read where it's used, at the time it's used.
+ *   Saving it takes effect without a restart.
+ * - `restart`: the value is read at boot. Saving stores it and marks it
+ *   pending (the `pendingRestart` diff, src/settings/pending.ts).
+ *
+ * This SUPERSEDES core-hardening §5.7's blanket "every `server.*` key
+ * is restart-required" (ruling 18): each core key is marked
+ * individually, and the reasons below are the audit's one-line record
+ * (the where-it's-read evidence for every entry).
+ *
+ * NOT here (deliberately — spec §13.1): the listen host (a launch
+ * option: `serve` binds `0.0.0.0`, `run` binds `127.0.0.1`) and the
+ * config dir (`SIGRUN_CONFIG_DIR`, env-only — it locates the settings
+ * file itself). Neither is a stored setting.
+ *
+ * Extension-declared fields are also NOT here: they default to `live`
+ * (§13.1); an extension marks a field `restart` when its factory reads
+ * the value at load (Task 3's sections carry that).
+ */
+/**
+ * Every core key, in `SettingsFile` declaration order (top-level keys
+ * first, then the `server.*` leaves). `test/settings-apply.test.ts`
+ * pins this list against the TYPE with a compile-time tie: a key added
+ * to `SettingsFile` without an entry here fails the suite naming it.
+ */
+export const CORE_SETTING_KEYS = [
+    // ── HarnessSettings pass-throughs: pi-durable re-reads per boundary ──
+    {
+        key: "steeringMode",
+        apply: "live",
+        section: "general",
+        reason: "pi-durable HarnessSettings pass-through, re-read at every resolution boundary",
+    },
+    {
+        key: "followUpMode",
+        apply: "live",
+        section: "general",
+        reason: "pi-durable HarnessSettings pass-through, re-read at every resolution boundary",
+    },
+    {
+        key: "retry.enabled",
+        apply: "live",
+        section: "general",
+        reason: "HarnessSettings.retry merge, re-read per resolution",
+    },
+    {
+        key: "retry.maxRetries",
+        apply: "live",
+        section: "general",
+        reason: "HarnessSettings.retry merge, re-read per resolution",
+    },
+    {
+        key: "retry.baseDelayMs",
+        apply: "live",
+        section: "general",
+        reason: "HarnessSettings.retry merge, re-read per resolution",
+    },
+    {
+        key: "retry.maxAgentDelayMs",
+        apply: "live",
+        section: "general",
+        reason: "HarnessSettings.retry merge, re-read per resolution",
+    },
+    {
+        key: "stream.timeoutMs",
+        apply: "live",
+        section: "general",
+        reason: "HarnessSettings.stream merge, re-read per resolution",
+    },
+    {
+        key: "stream.maxRetries",
+        apply: "live",
+        section: "general",
+        reason: "HarnessSettings.stream merge, re-read per resolution",
+    },
+    {
+        key: "stream.maxRetryDelayMs",
+        apply: "live",
+        section: "general",
+        reason: "HarnessSettings.stream merge, re-read per resolution",
+    },
+    // ── Per-use readers ──
+    {
+        key: "defaultTools",
+        apply: "live",
+        section: "tools",
+        reason: "read per conversation create (storeAgentChange), so a PATCH reaches new conversations",
+    },
+    {
+        key: "perModelThinking",
+        apply: "live",
+        section: "tools",
+        reason: "read per conversation create and configure",
+    },
+    {
+        key: "extensions",
+        apply: "restart",
+        section: "extensions",
+        reason: "boot reconciliation: syncPackages installs/uninstalls and the loader resolves the list at boot",
+    },
+    {
+        key: "jobs",
+        apply: "restart",
+        section: "advanced",
+        reason: "boot reconciliation: the file job list resolves into job records at boot",
+    },
+    {
+        key: "jobHistory.runs",
+        apply: "live",
+        section: "advanced",
+        reason: "read per prune at run-settle (spec §8.1, ruling 14)",
+    },
+    {
+        key: "jobHistory.revisions",
+        apply: "live",
+        section: "advanced",
+        reason: "read per prune at revision-write (spec §8.1, ruling 14)",
+    },
+    {
+        key: "defaultModel",
+        apply: "restart",
+        section: "general",
+        reason: "boot model resolution: env over file resolves once into the served default",
+    },
+    {
+        key: "namingModel",
+        apply: "live",
+        section: "general",
+        reason: "read per settled run by the auto-namer (src/harness/naming.ts)",
+    },
+    {
+        key: "defaultProvider.baseUrl",
+        apply: "restart",
+        section: "providers",
+        reason: "the env-driven provider's endpoint resolves into the boot provider construction",
+    },
+    {
+        key: "skills.sectionMaxBytes",
+        apply: "live",
+        section: "general",
+        reason: "read per skills-section render (the live cap closure in boot)",
+    },
+    {
+        key: "notifications.runSettled",
+        apply: "live",
+        section: "general",
+        reason: "read per run.settled event by the notifications surface",
+    },
+    {
+        key: "builtinExtensions.codemode",
+        apply: "restart",
+        section: "extensions",
+        reason: "the built-in set resolves at boot (a disabled built-in never loads)",
+    },
+    {
+        key: "builtinExtensions.mcp",
+        apply: "restart",
+        section: "extensions",
+        reason: "the built-in set resolves at boot (a disabled built-in never loads)",
+    },
+    {
+        key: "builtinExtensions.toolSearch",
+        apply: "restart",
+        section: "extensions",
+        reason: "the built-in set resolves at boot (a disabled built-in never loads)",
+    },
+    {
+        key: "builtinExtensions.oauth",
+        apply: "restart",
+        section: "extensions",
+        reason: "the built-in set resolves at boot (a disabled built-in never loads)",
+    },
+    {
+        key: "autoEnableCodemode",
+        apply: "live",
+        section: "tools",
+        reason: "read at conversation create alongside defaultTools",
+    },
+    // ── server.* (each key marked individually — ruling 18) ──
+    {
+        key: "server.port",
+        apply: "restart",
+        section: "server",
+        reason: "the listener binds at boot (serve's app.listen)",
+    },
+    {
+        key: "server.workspacePath",
+        apply: "restart",
+        section: "server",
+        reason: "boot-resolved workspace root (the workspace service is built once)",
+    },
+    {
+        key: "server.storagePath",
+        apply: "restart",
+        section: "server",
+        reason: "boot-resolved sqlite path (the storage opens once at boot)",
+    },
+    {
+        key: "server.extensionsDir",
+        apply: "restart",
+        section: "server",
+        reason: "deprecated path key (§6.7, accepted one release); root resolution is boot-time",
+    },
+    {
+        key: "server.maxUploadBytes",
+        apply: "restart",
+        section: "server",
+        reason: "route bodyLimit values are set at route registration (boot)",
+    },
+    {
+        key: "server.maxFileReadBytes",
+        apply: "restart",
+        section: "server",
+        reason: "the files/raw cap reads the boot-resolved config value per request",
+    },
+    {
+        key: "server.dataDir",
+        apply: "restart",
+        section: "server",
+        reason: "boot-resolved store root (resolveStoreRoots folds it once)",
+    },
+    {
+        key: "server.cacheDir",
+        apply: "restart",
+        section: "server",
+        reason: "boot-resolved store root",
+    },
+    {
+        key: "server.stateDir",
+        apply: "restart",
+        section: "server",
+        reason: "boot-resolved store root",
+    },
+    {
+        key: "server.publicUrl",
+        apply: "restart",
+        section: "server",
+        reason: "extension-route base URLs and notification deep links read the boot-resolved config",
+    },
+    {
+        key: "server.webui.enabled",
+        apply: "restart",
+        section: "interface",
+        reason: "the bundle resolves and mounts at serve time (boot)",
+    },
+    {
+        key: "server.webui.bundle",
+        apply: "restart",
+        section: "interface",
+        reason: "the bundle selection resolves at serve time (boot)",
+    },
+    {
+        key: "server.webuiBundle",
+        apply: "restart",
+        section: "interface",
+        reason: "deprecated alias of webui.bundle (one release); the selection resolves at serve time",
+    },
+    {
+        key: "server.timezone",
+        apply: "restart",
+        section: "server",
+        reason: "the jobs defaultTz resolves once into the schedule runtime at boot",
+    },
+    {
+        key: "server.compaction.enabled",
+        apply: "restart",
+        section: "advanced",
+        reason: "compaction policy resolves into the boot harness settings",
+    },
+    {
+        key: "server.compaction.reserveTokens",
+        apply: "restart",
+        section: "advanced",
+        reason: "compaction policy resolves into the boot harness settings",
+    },
+    {
+        key: "server.compaction.keepRecentTokens",
+        apply: "restart",
+        section: "advanced",
+        reason: "compaction policy resolves into the boot harness settings",
+    },
+    {
+        key: "server.compaction.backgroundTokens",
+        apply: "restart",
+        section: "advanced",
+        reason: "compaction policy resolves into the boot harness settings",
+    },
+    {
+        key: "server.memorySeam.hookDeadlineMs",
+        apply: "restart",
+        section: "advanced",
+        reason: "the event bus's bounds are set at open (boot)",
+    },
+    {
+        key: "server.memorySeam.idleThresholdMs",
+        apply: "restart",
+        section: "advanced",
+        reason: "the event bus's idle detection arms at open (boot)",
+    },
+    {
+        key: "server.memorySeam.workerDeadlineMs",
+        apply: "restart",
+        section: "advanced",
+        reason: "the event bus's worker bound is set at open (boot)",
+    },
+    {
+        key: "server.memorySeam.queueMax",
+        apply: "restart",
+        section: "advanced",
+        reason: "the event bus's queue bound is set at open (boot)",
+    },
+    {
+        key: "server.providers.refreshIntervalMinutes",
+        apply: "live",
+        section: "providers",
+        reason: "the interval scheduler re-arms on change (the settings-changed wiring in boot)",
+    },
+    {
+        key: "server.auth.methods",
+        apply: "restart",
+        section: "server",
+        reason: "the auth pipeline's method list resolves once at server construction",
+    },
+    {
+        key: "server.auth.sessionDays",
+        apply: "live",
+        section: "server",
+        reason: "read from the live settings store when a login creates a session",
+    },
+    {
+        key: "server.auth.proxy.trustedProxies",
+        apply: "restart",
+        section: "server",
+        reason: "proxy trust resolves once into the pipeline's peer check",
+    },
+    {
+        key: "server.auth.proxy.secretHeader",
+        apply: "restart",
+        section: "server",
+        reason: "header names resolve once into the pipeline's forward-auth stage",
+    },
+    {
+        key: "server.auth.proxy.userHeader",
+        apply: "restart",
+        section: "server",
+        reason: "header names resolve once into the pipeline's forward-auth stage",
+    },
+    {
+        key: "server.auth.proxy.groupsHeader",
+        apply: "restart",
+        section: "server",
+        reason: "header names resolve once into the pipeline's forward-auth stage",
+    },
+    {
+        key: "server.auth.proxy.nameHeader",
+        apply: "restart",
+        section: "server",
+        reason: "header names resolve once into the pipeline's forward-auth stage",
+    },
+    {
+        key: "server.auth.proxy.emailHeader",
+        apply: "restart",
+        section: "server",
+        reason: "header names resolve once into the pipeline's forward-auth stage",
+    },
+    {
+        key: "server.auth.proxy.autoProvision",
+        apply: "restart",
+        section: "server",
+        reason: "provisioning posture resolves once at pipeline construction",
+    },
+    {
+        key: "server.auth.adminGroups",
+        apply: "restart",
+        section: "server",
+        reason: "the admin-group mapping resolves once at pipeline construction",
+    },
+    {
+        key: "server.auth.allowedHosts",
+        apply: "restart",
+        section: "server",
+        reason: "the Host allowlist resolves once at pipeline construction",
+    },
+    {
+        key: "server.auth.allowedOrigins",
+        apply: "restart",
+        section: "server",
+        reason: "the Origin allowlist resolves once at pipeline construction",
+    },
+    {
+        key: "server.metrics.public",
+        apply: "restart",
+        section: "server",
+        reason: "the /metrics route's public gate registers at boot",
+    },
+    {
+        key: "server.dev",
+        apply: "restart",
+        section: "server",
+        reason: "read from the boot config (meta, U1 gallery, U3 error bodies)",
+    },
+    {
+        key: "server.supervised",
+        apply: "restart",
+        section: "server",
+        reason: "read from the boot config (U4 §13.3): gates POST /v1/admin/restart and meta's supervised — and a write can only take effect at the NEXT boot, since the route it gates is this boot's",
+    },
+    {
+        key: "server.backup.path",
+        apply: "restart",
+        section: "advanced",
+        reason: "the backup target and honesty window resolve into the boot config's health",
+    },
+    {
+        key: "server.backup.staleAfterHours",
+        apply: "restart",
+        section: "advanced",
+        reason: "the backup honesty window resolves into the boot config's health",
+    },
+    {
+        key: "server.backup.s3.bucket",
+        apply: "restart",
+        section: "advanced",
+        reason: "the backup target resolves into the boot config's health",
+    },
+    {
+        key: "server.backup.s3.prefix",
+        apply: "restart",
+        section: "advanced",
+        reason: "the backup target resolves into the boot config's health",
+    },
+    {
+        key: "server.backup.s3.endpoint",
+        apply: "restart",
+        section: "advanced",
+        reason: "the backup target resolves into the boot config's health",
+    },
+];
+/** The registry keyed by `key` (constant lookup for classification). */
+const BY_KEY = new Map(CORE_SETTING_KEYS.map((entry) => [entry.key, entry]));
+/**
+ * Classify one flattened key path. Keys the registry has not classified
+ * read as `"restart"` (conservative: a boot-read default is the safe
+ * assumption for an unclassified knob).
+ */
+export function applyOf(key) {
+    return BY_KEY.get(key)?.apply ?? "restart";
+}

package/dist/skills/index.js

@@ -197,6 +197,12 @@ export async function scanSkills(env, context, opts) {
     if (!listing.ok) {
         if (listing.error.code === "not_found")
             return [];
+        // An unavailable sandbox env (the host has no usable isolation
+        // helper) degrades to "no skills" rather than failing the submit:
+        // the expansion is a courtesy lookup, and a 500 here would strand
+        // an ordinary user message on a Landlock-less machine.
+        if (listing.error.message.includes("isolation_unavailable"))
+            return [];
         throw new Error(`Failed to list the ${SKILLS_DIRECTORY}/ directory: ${listing.error.message}`, { cause: listing.error });
     }
     const directories = listing.value

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

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.1] - 2026-10-28
+### Added
+- Additive listener metadata on the meta response: host, port, and
+  measured address families.
+
+## [0.2.0] - 2026-10-27
+### Added
+- Surface and block wire types extended for the U5/U6/U7 workstreams:
+  chat-block entry and state families, interaction and ambient bindings,
+  block transport contracts, and settings-section types.
+
 ## [0.1.2] - 2026-10-24
 ### Added
 - Extension-surface wire types, including block-instance and live-view

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

@@ -1,6 +1,6 @@
 /**
  * Per-resource sharing and content access (core hardening W1 Task 5, spec
- * §5.9 ruling 6/10: per-resource sharing; groups cut).
+ * §5.9 ruling 6/10: per-resource sharing; multi-user M3b adds groups).
  *
  * Part of the shared leaf package (`@sigrun/shared`): the server computes
  * access through `accessOf`, the clients render the `sharing` state — one
@@ -13,7 +13,7 @@
  * 2. ownerless resource → household write (everyone);
  * 3. user === owner → write;
  * 4. household sharing with a defined user → the shared level;
- * 5. people sharing including the user → the shared level;
+ * 5. people sharing including the user or one of their groups → the shared level;
  * 6. otherwise none (hidden: 404 on every :id route, absent from lists).
  *
  * Anonymous callers (a principal with no user) get nothing from a shared
@@ -30,6 +30,7 @@ export type Sharing = {
 } | {
     readonly scope: "people";
     readonly users: string[];
+    readonly groups?: string[];
     readonly level: "read" | "write";
 };
 /** The resolved access level of a principal to one resource. */
@@ -38,6 +39,7 @@ export type Access = "none" | "read" | "write";
 export interface AccessPrincipal {
     readonly user?: string;
     readonly superuser?: boolean;
+    readonly groups?: readonly string[];
 }
 /**
  * Resolve one principal's access to one resource. Rule order per the