@sigrun/sigrun 0.2.0 → 0.3.0

package/dist/server/routes/onboarding.js

@@ -17,7 +17,12 @@ import { timingSafeEqual } from "node:crypto";
 import { withClaimLock } from "../auth/claim-lock.js";
 import { ipAllowed } from "../auth/ip.js";
 import { isLoopbackHost } from "../auth/loopback.js";
+import { ownHostPeerPermitted } from "../auth/own-host.js";
+import { previewProxyUser, provisionProxyUser } from "../auth/proxy-identity.js";
+import { ProxyRejectReason, warnProxyRejected, } from "../auth/proxy-diagnostic.js";
+import { requiresProxyVouch } from "../auth/proxy-only.js";
 import { readSetupCode, clearSetupCode } from "../../harness/identity/index.js";
+import { normalizeTypedUsername } from "../../harness/identity/typed-username.js";
 import { setupCodeMatches } from "../../harness/identity/setup-code-check.js";
 import { AdmissionRefusedError } from "../../harness/identity/users.js";
 import { stampSessionOwner } from "../helpers.js";
@@ -28,8 +33,6 @@ function headerOf(request, name) {
     const single = Array.isArray(value) ? value[0] : value;
     return single?.trim() || undefined;
 }
-/** The username rule (spec §5.8, shared with the directory's own check). */
-const USERNAME_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
 /** Constant-time string equality (the pipeline's discipline). */
 function timingSafeStringEqual(a, b) {
     const left = Buffer.from(a, "utf8");
@@ -52,8 +55,24 @@ function timingSafeStringEqual(a, b) {
 function resolveProxyIdentity(request, ctx) {
     if (!ctx.methods.includes("proxy"))
         return undefined;
+    // The rejection diagnostic (proxy-trust C1): while the instance is
+    // UNCLAIMED, every rejection branch reports WHY via the shared,
+    // throttled warn — these routes sit on the public path the pipeline
+    // never visits, so without this their proxy rejections are silent.
+    // Once claimed the onboarding surface no longer needs the signal.
+    const diagnose = !ctx.opened.identity.users.isClaimed();
     const { proxy } = ctx.config.auth;
     if (!ipAllowed(request.socket.remoteAddress, proxy.trustedProxies)) {
+        if (diagnose)
+            warnProxyRejected(request, ProxyRejectReason.UNTRUSTED);
+        return undefined;
+    }
+    // C5: the same own-host discipline as the pipeline — an own-host
+    // peer reached through a range without the shared secret never
+    // vouches (any local process could claim the first admin).
+    if (!ownHostPeerPermitted(request.socket.remoteAddress, proxy.trustedProxies, proxy.secret !== undefined && proxy.secretHeader !== undefined)) {
+        if (diagnose)
+            warnProxyRejected(request, ProxyRejectReason.OWN_HOST);
         return undefined;
     }
     if (proxy.secret !== undefined && proxy.secretHeader !== undefined) {
@@ -62,16 +81,32 @@ function resolveProxyIdentity(request, ctx) {
         delete request.headers[name];
         if (presented === undefined ||
             !timingSafeStringEqual(presented, proxy.secret)) {
+            if (diagnose) {
+                warnProxyRejected(request, ProxyRejectReason.secretReason(proxy.secretHeader));
+            }
             return undefined;
         }
     }
     const user = headerOf(request, proxy.userHeader);
-    if (user === undefined || !USERNAME_PATTERN.test(user))
+    // An absent OR EMPTY (headerOf trims to undefined) user header is the
+    // missing-header reason; a present-but-unrepresentable claim is the
+    // unusable-claim reason. Neither line carries the claimed VALUE.
+    if (user === undefined) {
+        if (diagnose) {
+            warnProxyRejected(request, ProxyRejectReason.missingHeaderReason(proxy.userHeader.toLowerCase()));
+        }
         return undefined;
+    }
+    const preview = previewProxyUser(ctx.opened.identity, user);
+    if (preview === undefined) {
+        if (diagnose)
+            warnProxyRejected(request, ProxyRejectReason.UNUSABLE);
+        return undefined;
+    }
     const name = headerOf(request, proxy.nameHeader);
     const email = headerOf(request, proxy.emailHeader);
     return {
-        user,
+        ...preview,
         ...(name === undefined ? {} : { name }),
         ...(email === undefined ? {} : { email }),
     };
@@ -132,6 +167,15 @@ export function registerOnboardingRoutes(app, ctx) {
         }
         const proxyIdentity = resolveProxyIdentity(request, ctx);
         const loopback = isLoopbackHost(ctx.listenHost);
+        // C2: a proxy-only non-loopback server creates accounts ONLY
+        // through a proxy vouch — refuse BEFORE code evaluation, so even
+        // a valid setup code or invite code cannot mint an account
+        // unvouched on this posture. Mixed [proxy, token] and loopback
+        // binds keep the code paths.
+        if (requiresProxyVouch(ctx.methods, ctx.listenHost) &&
+            proxyIdentity === undefined) {
+            return await reply.code(403).send({ error: "proxy_identity_required" });
+        }
         // The code's validity is evaluated ONCE, BEFORE the mutex: the winner
         // clears the setup-code file inside its critical section, so a claim
         // that loses the race must still be recognizable as having held a
@@ -149,25 +193,29 @@ export function registerOnboardingRoutes(app, ctx) {
                     // code ("the first invite" — same shape, admin grant).
                     let grant;
                     if (proxyIdentity !== undefined) {
-                        // Proxy claims take identity from the headers, verbatim
-                        // (body identity fields are ignored — the proxy vouched).
-                        grant = { ...proxyIdentity, source: "proxy" };
+                        // Body identity fields are ignored — the proxy vouched. This
+                        // route already holds the claim lock, so call the lock-free
+                        // resolver body, never the pipeline entry.
+                        const resolved = await provisionProxyUser(identity, proxyIdentity.subject, {
+                            ...(proxyIdentity.name === undefined ? {} : { name: proxyIdentity.name }),
+                            ...(proxyIdentity.email === undefined ? {} : { email: proxyIdentity.email }),
+                        }, { provision: true, admin: true });
+                        if (resolved.kind === "invalid") {
+                            return { status: 400, error: "invalid_username" };
+                        }
+                        if (resolved.kind === "not_provisioned") {
+                            return { status: 409, error: "already_claimed" };
+                        }
+                        grant = resolved.record;
                     }
-                    else if (loopback) {
+                    else if (loopback || codeWasSetup) {
                         if (validated.user === undefined)
                             return { status: 400, error: "invalid_body" };
+                        const typed = normalizeTypedUsername(validated.user, (key) => identity.users.get(key) !== undefined);
+                        if (!typed.ok)
+                            return { status: typed.error === "invalid_username" ? 400 : 409, error: typed.error };
                         grant = {
-                            user: validated.user,
-                            ...(validated.name === undefined ? {} : { name: validated.name }),
-                            ...(validated.email === undefined ? {} : { email: validated.email }),
-                            source: "cli",
-                        };
-                    }
-                    else if (codeWasSetup) {
-                        if (validated.user === undefined)
-                            return { status: 400, error: "invalid_body" };
-                        grant = {
-                            user: validated.user,
+                            user: typed.key,
                             ...(validated.name === undefined ? {} : { name: validated.name }),
                             ...(validated.email === undefined ? {} : { email: validated.email }),
                             source: "cli",
@@ -177,10 +225,8 @@ export function registerOnboardingRoutes(app, ctx) {
                         // Wrong or absent code where one is required.
                         return { status: 403, error: "invalid_code" };
                     }
-                    if (!USERNAME_PATTERN.test(grant.user)) {
-                        return { status: 400, error: "invalid_username" };
-                    }
-                    const record = await identity.users.add({
+                    // The proxy resolver already added and linked its record.
+                    const record = "createdAt" in grant ? grant : await identity.users.add({
                         user: grant.user,
                         ...(grant.name === undefined ? {} : { name: grant.name }),
                         ...(grant.email === undefined ? {} : { email: grant.email }),
@@ -207,17 +253,31 @@ export function registerOnboardingRoutes(app, ctx) {
                     return { status: 409, error: "already_claimed" };
                 }
                 if (validated.code !== undefined) {
-                    const invite = validated.user === undefined
-                        ? undefined
-                        : await identity.invites.redeem(validated.code, validated.user);
+                    if (validated.user === undefined) {
+                        return { status: 403, error: "invalid_code" };
+                    }
+                    const typed = normalizeTypedUsername(validated.user, (key) => identity.users.get(key) !== undefined);
+                    if (!typed.ok && typed.error === "invalid_username") {
+                        return { status: 400, error: typed.error };
+                    }
+                    // Validate before revealing a collision, but never consume
+                    // the invite until every refusal check has passed.
+                    const invite = await identity.invites.peek(validated.code);
                     if (invite === undefined) {
                         return { status: 403, error: "invalid_code" };
                     }
+                    if (!typed.ok)
+                        return { status: 409, error: typed.error };
+                    identity.users.checkAdmission();
+                    const redeemed = await identity.invites.redeem(validated.code, typed.key);
+                    if (redeemed === undefined) {
+                        return { status: 403, error: "invalid_code" };
+                    }
                     const record = await identity.users.add({
-                        user: validated.user,
+                        user: typed.key,
                         ...(validated.name === undefined ? {} : { name: validated.name }),
                         ...(validated.email === undefined ? {} : { email: validated.email }),
-                        admin: invite.admin,
+                        admin: redeemed.admin,
                         source: "invite",
                     });
                     return { status: 200, record };
@@ -228,17 +288,17 @@ export function registerOnboardingRoutes(app, ctx) {
                 if (proxyIdentity === undefined) {
                     return { status: 409, error: "already_claimed" };
                 }
-                const existing = identity.users.get(proxyIdentity.user);
-                if (existing !== undefined)
-                    return { status: 200, record: existing };
-                const record = await identity.users.add({
-                    user: proxyIdentity.user,
+                const resolved = await provisionProxyUser(identity, proxyIdentity.subject, {
                     ...(proxyIdentity.name === undefined ? {} : { name: proxyIdentity.name }),
                     ...(proxyIdentity.email === undefined ? {} : { email: proxyIdentity.email }),
-                    admin: false,
-                    source: "proxy",
-                });
-                return { status: 200, record };
+                }, 
+                // A codeless onboarding claim has always auto-provisioned the
+                // vouched identity, independent of the pipeline's policy.
+                { provision: true, admin: false });
+                if (resolved.kind !== "user") {
+                    return { status: 409, error: "already_claimed" };
+                }
+                return { status: 200, record: resolved.record };
             }
             catch (error) {
                 if (error instanceof AdmissionRefusedError) {

package/dist/server/session-meta.js

@@ -49,6 +49,7 @@ export const SessionMetaDoc = defineDoc({
     kind: "sigrun.session-meta",
     version: 1,
     scope: "conversation",
+    checkpointWhen: () => false,
     history: "latest",
     fork: "current",
     // Defensive copy (the alias-free-ownership pattern): the tracker takes

package/dist/server/shutdown.js

@@ -2,8 +2,9 @@
  * The ordered shutdown (gateway C2's extraction of serve.ts's inline
  * `shutdown`): eight steps, each in its own try/catch so a failure never
  * skips the remaining steps, with every failure collected into one
- * `AggregateError("sigrun shutdown failed")` after ALL steps ran (the
- * pre-extraction semantics, byte-for-byte).
+ * `AggregateError("sigrun shutdown failed")` after ALL steps ran. Every
+ * asynchronous stage has a fixed cap; reaching one abandons only that wait,
+ * logs, and continues, so the composed shutdown has a fixed worst case.
  *
  * The order (spec §8.0 — the gateway lifecycle slots between the server
  * drain and the event-bus flush):
@@ -28,6 +29,82 @@
  * Does NOT exit the process — the caller owns exit policy (the deploy
  * entry exits 0/1; the CLI's `run` returns to its exit code).
  */
+import { SHUTDOWN_SETTLE_WAIT_MS, WORKER_SHUTDOWN_AWAIT_MS, } from "../harness/event-bus.js";
+/** Every ordered stage has a bound; these are the bounds used by the budget. */
+export const END_STREAMS_SHUTDOWN_CAP_MS = 0;
+export const CLOSE_APP_SHUTDOWN_CAP_MS = 10_000;
+export const GATEWAY_STOP_INTAKE_SHUTDOWN_CAP_MS = 10_000;
+export const GATEWAY_STOP_SHUTDOWN_CAP_MS = 10_000;
+export const SANDBOX_WORKERS_SHUTDOWN_CAP_MS = 5_000;
+export const PROVIDER_REFRESH_SHUTDOWN_CAP_MS = 2_000;
+/**
+ * Measured against a real 1.4.0 boot over a copy of the durable-v1 fixture
+ * in test/shutdown-order.test.ts (0.6ms on the implementation run). The test
+ * asserts this cap is at least four times that measurement, so a slow but
+ * healthy close never gets converted into a counted restart by a guessed cap.
+ */
+export const CLOSE_HARNESS_SHUTDOWN_CAP_MS = 10_000;
+/**
+ * The event bus's bounded stages: worker stop + the initial drain + the
+ * live-run settle wait AND the final drain that can start just before its
+ * deadline + all extension handlers under one shared deadline. The settle
+ * wait is a per-boot test override; the production budget uses its default.
+ * This bounds each drain WAIT, not work a caller can ride on an already
+ * running side lane: the grace holds when the side lane is idle at shutdown
+ * (the quiet admission window). An outer boundedStage wrap or stopping
+ * enqueue at shutdownSequence entry is a deferred structural option.
+ */
+export function eventBusShutdownCapMs(config) {
+    return (WORKER_SHUTDOWN_AWAIT_MS +
+        config.hookDeadlineMs +
+        SHUTDOWN_SETTLE_WAIT_MS +
+        config.hookDeadlineMs +
+        config.hookDeadlineMs);
+}
+/** The fixed worst case of the complete ordered shutdown, in milliseconds. */
+export function shutdownBudgetMs(config) {
+    return (END_STREAMS_SHUTDOWN_CAP_MS +
+        CLOSE_APP_SHUTDOWN_CAP_MS +
+        GATEWAY_STOP_INTAKE_SHUTDOWN_CAP_MS +
+        eventBusShutdownCapMs(config) +
+        GATEWAY_STOP_SHUTDOWN_CAP_MS +
+        SANDBOX_WORKERS_SHUTDOWN_CAP_MS +
+        PROVIDER_REFRESH_SHUTDOWN_CAP_MS +
+        CLOSE_HARNESS_SHUTDOWN_CAP_MS);
+}
+/**
+ * Await one stage without allowing a wedged implementation to outlive its
+ * budget share. Abandonment is logged; the next ordered stage still runs.
+ */
+async function boundedStage(name, capMs, run) {
+    let timer;
+    const deadline = new Promise((resolve) => {
+        timer = setTimeout(() => {
+            console.error(`sigrun: shutdown stage ${name} exceeded ${capMs}ms — abandoning the wait`);
+            resolve();
+        }, capMs);
+    });
+    let abandoned = false;
+    const stage = Promise.resolve().then(run);
+    // The race can abandon a stage that later rejects. Observe that rejection
+    // here so it is logged rather than becoming an unhandled rejection. An
+    // early rejection already propagated to createShutdown's failure collector,
+    // so it must not also be reported as an abandonment.
+    stage.catch((error) => {
+        if (abandoned) {
+            console.error(`sigrun: shutdown stage ${name} rejected after abandonment:`, error);
+        }
+    });
+    try {
+        await Promise.race([stage, deadline.then(() => {
+                abandoned = true;
+            })]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
 /**
  * Build the ordered shutdown over the eight steps. Failures from ANY step
  * are collected (the remaining steps still run) and thrown together as
@@ -41,52 +118,52 @@ export function createShutdown(steps) {
             steps.endStreams();
         }
         catch (error) {
-            failures.push(error);
+            failures.push({ stage: "endStreams", error });
         }
         try {
-            await steps.closeApp();
+            await boundedStage("closeApp", CLOSE_APP_SHUTDOWN_CAP_MS, () => steps.closeApp());
         }
         catch (error) {
-            failures.push(error);
+            failures.push({ stage: "closeApp", error });
         }
         try {
-            await steps.gateway.stopIntake();
+            await boundedStage("gateway.stopIntake", GATEWAY_STOP_INTAKE_SHUTDOWN_CAP_MS, () => steps.gateway.stopIntake());
         }
         catch (error) {
-            failures.push(error);
+            failures.push({ stage: "gateway.stopIntake", error });
         }
         try {
             await steps.eventBusShutdown();
         }
         catch (error) {
-            failures.push(error);
+            failures.push({ stage: "eventBusShutdown", error });
         }
         try {
-            await steps.gateway.stop();
+            await boundedStage("gateway.stop", GATEWAY_STOP_SHUTDOWN_CAP_MS, () => steps.gateway.stop());
         }
         catch (error) {
-            failures.push(error);
+            failures.push({ stage: "gateway.stop", error });
         }
         try {
-            await steps.stopSandboxWorkers();
+            await boundedStage("stopSandboxWorkers", SANDBOX_WORKERS_SHUTDOWN_CAP_MS, () => steps.stopSandboxWorkers());
         }
         catch (error) {
-            failures.push(error);
+            failures.push({ stage: "stopSandboxWorkers", error });
         }
         try {
             await steps.stopProviderRefresh();
         }
         catch (error) {
-            failures.push(error);
+            failures.push({ stage: "stopProviderRefresh", error });
         }
         try {
-            await steps.closeHarness();
+            await boundedStage("closeHarness", CLOSE_HARNESS_SHUTDOWN_CAP_MS, () => steps.closeHarness());
         }
         catch (error) {
-            failures.push(error);
+            failures.push({ stage: "closeHarness", error });
         }
         if (failures.length > 0) {
-            throw new AggregateError(failures, "sigrun shutdown failed");
+            throw new AggregateError(failures.map(({ error }) => error), `sigrun shutdown failed: ${failures.map(({ stage }) => stage).join(", ")}`);
         }
     };
 }

package/dist/settings/registry.js

@@ -290,6 +290,12 @@ export const CORE_SETTING_KEYS = [
         section: "advanced",
         reason: "compaction policy resolves into the boot harness settings",
     },
+    {
+        key: "server.compaction.modelOverrides",
+        apply: "restart",
+        section: "advanced",
+        reason: "compaction policy resolves into the boot harness settings",
+    },
     {
         key: "server.memorySeam.hookDeadlineMs",
         apply: "restart",

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).
 
 ## [Unreleased]
+### Added
+- The `./usernames` export for shared username derivation and validation.
+
+## [0.3.0] - 2026-10-29
+### Added
+- `ServerSettings.compaction.modelOverrides` declares per-model compaction
+  policy overrides in the shared settings wire type.
+
+## [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

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

@@ -136,6 +136,20 @@ export interface ServerSettings {
         readonly reserveTokens?: number;
         readonly keepRecentTokens?: number;
         readonly backgroundTokens?: number;
+        /**
+         * Per-model compaction policy overrides, keyed by the exact
+         * `provider/modelId` string pi-durable composes — a chain-shaped
+         * model id doubles the prefix (e.g. `bifrost/bifrost/<chain>`).
+         * Each field replaces the harness-wide one for that model, so a
+         * small-window model can sit alongside the large-window default.
+         * Boot-time lifetime, like the rest of compaction.
+         */
+        readonly modelOverrides?: Readonly<Record<string, Partial<{
+            enabled: boolean;
+            reserveTokens: number;
+            keepRecentTokens: number;
+            backgroundTokens: number;
+        }>>>;
     };
     /**
      * The memory-seam bounds (memory-seam Task 6), mirroring the

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

@@ -0,0 +1,8 @@
+export declare const MAX_USERNAME_LENGTH = 128;
+export declare const MAX_SUFFIX_ATTEMPTS = 10000;
+export declare class UsernameExhaustedError extends Error {
+}
+export declare function deriveUsername(input: string): string | undefined;
+export declare function isUsernameKey(s: string): boolean;
+export declare function foldSubject(s: string): string;
+export declare function withSuffix(base: string, taken: (key: string) => boolean): string;

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

@@ -0,0 +1,39 @@
+export const MAX_USERNAME_LENGTH = 128;
+export const MAX_SUFFIX_ATTEMPTS = 10_000;
+const COMBINING_MARKS = /\p{M}/gu;
+const AT_SIGNS = /@/g;
+const INVALID_CHARACTERS = /[^a-z0-9._-]/g;
+const LEADING_NON_ALPHANUMERIC = /^[^a-z0-9]+/;
+const USERNAME_KEY = /^[a-z0-9][a-z0-9._-]*$/;
+export class UsernameExhaustedError extends Error {
+}
+export function deriveUsername(input) {
+    const derived = input
+        .normalize("NFKD")
+        .replace(COMBINING_MARKS, "")
+        .toLowerCase()
+        .replace(AT_SIGNS, "_")
+        .replace(INVALID_CHARACTERS, "-")
+        .replace(LEADING_NON_ALPHANUMERIC, "")
+        .slice(0, MAX_USERNAME_LENGTH);
+    return derived === "" ? undefined : derived;
+}
+export function isUsernameKey(s) {
+    return s.length <= MAX_USERNAME_LENGTH && USERNAME_KEY.test(s);
+}
+export function foldSubject(s) {
+    return s.normalize("NFC").toLowerCase();
+}
+export function withSuffix(base, taken) {
+    if (!taken(base)) {
+        return base;
+    }
+    for (let suffix = 2; suffix <= MAX_SUFFIX_ATTEMPTS; suffix += 1) {
+        const suffixText = `-${suffix}`;
+        const candidate = `${base.slice(0, MAX_USERNAME_LENGTH - suffixText.length)}${suffixText}`;
+        if (!taken(candidate)) {
+            return candidate;
+        }
+    }
+    throw new UsernameExhaustedError(`No available username for "${base}"`);
+}

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

@@ -403,11 +403,38 @@ export type WorkerStatus = {
     readonly lastError?: string;
 };
 /** The `GET /v1/meta` payload (spec §5; the health block is Task 9e). */
+/**
+ * The measured listener facts (release-readiness Task 1, serving spec §2):
+ * captured ONCE when the listener goes live (never probed per request) and
+ * retained on the server context; `GET /v1/meta` projects them verbatim.
+ */
+export interface ListenerInfo {
+    /** The effective host string supplied to `listen` — never a resolved peer. */
+    readonly host: string;
+    /** The configured/selected port the listener bound. */
+    readonly port: number;
+    /**
+     * The address families the listener accepts, in stable `ipv4`, `ipv6`
+     * order. Literal binds report the bound socket's family; the `::`
+     * wildcard reports exactly the loopback families a startup reachability
+     * check connected on (measured, never inferred from the wildcard
+     * spelling). Empty on a server that never listened (a hand-built test
+     * server projecting intent only).
+     */
+    readonly families: readonly ("ipv4" | "ipv6")[];
+}
 export interface MetaResponse {
     /** The sigrun server's own version (the package manifest). */
     readonly version: string;
     readonly harnessVersion: string;
     readonly schemaVersion: string;
+    /**
+     * The listener facts (release-readiness Task 1, serving spec §2). A
+     * REQUIRED field on this type; OLDER SERVERS (≤0.2.0) omit it on the
+     * wire, so clients consuming it must tolerate its absence during
+     * mixed-version upgrades.
+     */
+    readonly listener: ListenerInfo;
     readonly extensions: readonly {
         readonly name: string;
         readonly status: string;
@@ -811,7 +838,9 @@ export interface OnboardingState {
     readonly methods: readonly ("token" | "proxy")[];
     readonly codeRequired: boolean;
     readonly proxyIdentity?: {
+        /** The would-be directory key; `subject` is the raw proxy header. */
         readonly user: string;
+        readonly subject: string;
         readonly name?: string;
         readonly email?: string;
     };
@@ -880,9 +909,9 @@ export interface TokenCreateResponse {
 }
 /**
  * One external identity linked to a directory user (multi-user §11.3):
- * the `accounts.json` record verbatim. `provider` is `chat:<channel>` or
- * `login:<slug>:<id>`; `subject` is the provider's stable subject
- * (numeric id, `+E.164`, email-shaped — opaque to sigrun).
+ * the `accounts.json` record verbatim. `provider` is `proxy`,
+ * `chat:<channel>`, or `login:<slug>:<id>`; `subject` is the provider's
+ * stable subject (numeric id, `+E.164`, email-shaped — opaque to sigrun).
  *
  * Served to extensions as `host.accounts` and to users as
  * `GET /v1/auth/accounts`.
@@ -892,7 +921,7 @@ export interface AccountLinkWire {
     readonly subject: string;
     readonly user: string;
     readonly linkedAt: number;
-    readonly via: "login" | "self" | "pairing" | "admin";
+    readonly via: "login" | "self" | "pairing" | "admin" | "proxy";
 }
 /**
  * The `GET /v1/auth/accounts` payload (multi-user §11.3): the caller's

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

@@ -1,6 +1,6 @@
 {
 	"name": "@sigrun/shared",
-	"version": "0.2.0",
+	"version": "0.3.0",
 	"description": "sigrun shared leaf package \u2014 theme tokens, turn/conversation shaping, and the channel wire types (pure leaf, zero dependencies)",
 	"type": "module",
 	"exports": {
@@ -8,6 +8,10 @@
 			"types": "./dist/themes.d.ts",
 			"default": "./dist/themes.js"
 		},
+		"./usernames": {
+			"types": "./dist/usernames.d.ts",
+			"default": "./dist/usernames.js"
+		},
 		"./conversations": {
 			"types": "./dist/conversations.d.ts",
 			"default": "./dist/conversations.js"

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sigrun/sigrun",
-	"version": "0.2.0",
+	"version": "0.3.0",
 	"description": "Durable personal assistant on pi-durable",
 	"type": "module",
 	"exports": {
@@ -30,7 +30,7 @@
 		"test": "vitest run",
 		"typecheck": "tsc --noEmit",
 		"build:shared": "npm --workspace @sigrun/shared run build",
-		"build": "npm run build:shared && tsc -p tsconfig.build.json && tsc -p tsconfig.extension.json && node -e \"require('node:fs').rmSync('dist/extension.js',{force:true})\"",
+		"build": "npm run build:shared && tsc -p tsconfig.build.json && tsc -p tsconfig.extension.json && node scripts/stamp-block-build.mjs && node -e \"require('node:fs').rmSync('dist/extension.js',{force:true})\"",
 		"build:webui": "npm --workspace @sigrun/webui run build",
 		"typecheck:webui": "npm --workspace @sigrun/webui run typecheck",
 		"test:e2e": "npm run build:webui && npm --workspace @sigrun/webui run test:e2e",
@@ -39,19 +39,20 @@
 	},
 	"dependencies": {
 		"@aws-sdk/client-s3": "^3.1154.0",
-		"@earendil-works/chord": "1.3.0",
-		"@earendil-works/pi-ai": "1.3.0",
-		"@earendil-works/pi-durable": "1.3.0",
+		"@earendil-works/chord": "1.4.0",
+		"@earendil-works/pi-ai": "1.4.0",
+		"@earendil-works/pi-durable": "1.4.0",
 		"@earendil-works/pi-tui": "^1.3.0",
 		"@fastify/static": "^10.1.7",
-		"@sigrun/ext-codemode": "0.1.1",
-		"@sigrun/ext-gateway": "0.1.1",
-		"@sigrun/ext-mcp": "0.2.1",
-		"@sigrun/ext-tool-search": "0.1.1",
+		"@sigrun/ext-codemode": "0.1.2",
+		"@sigrun/ext-gateway": "0.1.4",
+		"@sigrun/ext-mcp": "0.2.2",
+		"@sigrun/ext-tool-search": "0.1.2",
 		"@sigrun/oauth": "0.1.1",
-		"@sigrun/shared": "0.2.0",
+		"@sigrun/shared": "0.3.0",
 		"croner": "^10.0.1",
 		"fastify": "^5.12.7",
+		"semver": "^7.8.5",
 		"sharp": "^0.35.5",
 		"typebox": "1.3.27"
 	},
@@ -59,12 +60,13 @@
 		"@sigrun/shared"
 	],
 	"optionalDependencies": {
-		"@sigrun/sandbox-linux-arm64": "0.2.0",
-		"@sigrun/sandbox-linux-x64": "0.2.0",
-		"@sigrun/tui": "0.2.0"
+		"@sigrun/sandbox-linux-arm64": "0.3.0",
+		"@sigrun/sandbox-linux-x64": "0.3.0",
+		"@sigrun/tui": "0.3.0"
 	},
 	"devDependencies": {
 		"@types/node": "^26.6.4",
+		"@types/semver": "^7.8.0",
 		"fast-check": "^4.10.2",
 		"tsx": "^4.23.15",
 		"typescript": "^7.0.2",
@@ -90,8 +92,7 @@
 		"THIRD_PARTY_NOTICES.md",
 		"README.md",
 		"LICENSE",
-		"CHANGELOG.md",
-		"CONTEXT.md"
+		"CHANGELOG.md"
 	],
 	"allowScripts": {
 		"@google/genai@2.21.0": true,