@vellumai/cli 0.11.7-staging.2 → 0.11.8-staging.1

package/node_modules/@vellumai/local-mode/src/retire.ts

@@ -1,11 +1,17 @@
 import { spawn } from "node:child_process";
 
+import {
+  DAEMON_STOP_TIMEOUT_MS,
+  HOST_WRAPPER_LONG_HEADROOM_MS,
+} from "./lifecycle-budgets";
 import type { CliInvocation } from "./util";
 
-const RETIRE_TIMEOUT_MS = 60_000;
+const RETIRE_TIMEOUT_MS =
+  DAEMON_STOP_TIMEOUT_MS + HOST_WRAPPER_LONG_HEADROOM_MS;
 
 export type RetireResult =
-  { ok: true } | { ok: false; status: number; error: string };
+  | { ok: true }
+  | { ok: false; status: number; error: string };
 
 export interface RetireOptions {
   platformToken?: string;
@@ -50,7 +56,7 @@ export function runRetire(
       finish({
         ok: false,
         status: 500,
-        error: "Retire timed out after 60 seconds",
+        error: `Retire timed out after ${RETIRE_TIMEOUT_MS / 1000} seconds`,
       });
     }, RETIRE_TIMEOUT_MS);
 

package/node_modules/@vellumai/local-mode/src/sleep.ts

@@ -1,12 +1,12 @@
 import { spawn } from "node:child_process";
 
+import {
+  DAEMON_STOP_TIMEOUT_MS,
+  HOST_WRAPPER_HEADROOM_MS,
+} from "./lifecycle-budgets";
 import type { CliInvocation } from "./util";
 
-// The CLI's `sleep` command uses a 120s SIGKILL ceiling for the assistant
-// daemon (WAL checkpoint can be slow on large databases) plus 7s for the
-// gateway drain window. The wrapper timeout must sit above that total so a
-// slow-but-succeeding sleep isn't killed and misreported as a timeout.
-const SLEEP_TIMEOUT_MS = 150_000;
+const SLEEP_TIMEOUT_MS = DAEMON_STOP_TIMEOUT_MS + HOST_WRAPPER_HEADROOM_MS;
 
 export type SleepResult =
   | { ok: true }

package/node_modules/@vellumai/service-contracts/package.json

@@ -11,6 +11,7 @@
     "./client-metadata": "./src/client-metadata.ts",
     "./credential-rpc": "./src/credential-rpc.ts",
     "./ingress": "./src/ingress.ts",
+    "./no-response": "./src/no-response.ts",
     "./remote-web-pairing": "./src/remote-web-pairing.ts",
     "./twilio-ingress": "./src/twilio-ingress.ts",
     "./trust-rules": "./src/trust-rules.ts",

package/node_modules/@vellumai/service-contracts/src/channels.ts

@@ -66,6 +66,13 @@ export function isChannelId(value: unknown): value is ChannelId {
  * That irregularity is why this is stated rather than derived from the key,
  * and it is stated here because this file already owns what a channel is.
  *
+ * Both senses can hold a user token, which is the sharpest edge. The `slack`
+ * integration's persisted token *is* the installer's user token, held on its
+ * OAuth connection. `slack_channel` holds an optional `user_token` in the
+ * credential store, beside its bot and app tokens. Same words, different
+ * homes, and only the second is a credential-store key: a pasted token is
+ * always the channel's, because the integration's never leaves the exchange.
+ *
  * Deliberately only the key. What fields each credential requires is declared
  * once already, per service, in the gateway's credential specs; restating it
  * here would be a second copy of a different fact.

package/node_modules/@vellumai/service-contracts/src/index.ts

@@ -27,6 +27,7 @@ export * from "./handles.js";
 export * from "./rpc.js";
 export * from "./trust-rules.js";
 export * from "./ingress.js";
+export * from "./no-response.js";
 export * from "./remote-web-pairing.js";
 export * from "./twilio-ingress.js";
 export * from "./url-normalization.js";

package/node_modules/@vellumai/service-contracts/src/no-response.ts

@@ -0,0 +1,84 @@
+/**
+ * The `<no_response/>` sentinel: the cross-service convention for a turn
+ * that deliberately produces no user-visible reply.
+ *
+ * The model emits it, the daemon stamps and strips it, channel delivery
+ * suppresses it, and clients hold live-streamed prefixes of it back from
+ * display. One definition here keeps every consumer's parsing identical;
+ * a hand-rolled copy in any one of them is how the case-sensitivity of a
+ * regex drifts.
+ */
+
+/** Matches a message whose entire content is the sentinel. */
+const NO_RESPONSE_ONLY_RE = /^\s*<no_response\s*\/?>\s*$/i;
+
+/**
+ * Whether `text` is nothing but the sentinel: the whole reply is a
+ * deliberate non-response, as opposed to real content with an inline
+ * sentinel mixed in.
+ */
+export function isNoResponseOnlyText(text: string): boolean {
+  return NO_RESPONSE_ONLY_RE.test(text);
+}
+
+/** Matches every sentinel occurrence for stripping it out of mixed content. */
+export const NO_RESPONSE_INLINE_RE = /<no_response\s*\/?>/gi;
+
+/**
+ * Detection variant without the `g` flag: a `g`-flagged regex is stateful
+ * under `.test()` (it resumes from `lastIndex`), so reusing
+ * {@link NO_RESPONSE_INLINE_RE} for detection would alternate between
+ * matches and misses across calls.
+ */
+const NO_RESPONSE_MARKER_RE = new RegExp(NO_RESPONSE_INLINE_RE.source, "i");
+
+/** Whether `text` contains the sentinel anywhere. */
+export function containsNoResponseMarker(text: string): boolean {
+  return NO_RESPONSE_MARKER_RE.test(text);
+}
+
+/** Removes every sentinel occurrence, trimming the leftover whitespace. */
+export function stripNoResponseMarkers(text: string): string {
+  return text.replace(NO_RESPONSE_INLINE_RE, "").trim();
+}
+
+const NO_RESPONSE_SENTINEL_FORMS = [
+  "<no_response/>",
+  "<no_response />",
+  "<no_response>",
+] as const;
+
+/**
+ * Whether `text` could still grow into the sentinel, i.e. it is a leading
+ * substring of one of its forms. Holding on these keeps a slowly-streamed
+ * `<no_response/>` from surfacing as visible partial content.
+ */
+export function isPotentialNoResponsePrefix(text: string): boolean {
+  const lower = text.trim().toLowerCase();
+  if (lower.length === 0) {
+    return false;
+  }
+  return NO_RESPONSE_SENTINEL_FORMS.some((sentinel) =>
+    sentinel.startsWith(lower),
+  );
+}
+
+/**
+ * Whether `text` carries user-visible content worth acting on now. Returns
+ * `false` for empty text, the standalone sentinel, and any prefix that could
+ * still complete into one; returns `true` once real content remains after
+ * stripping inline sentinels.
+ */
+export function hasDeliverableAssistantText(text: string): boolean {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) {
+    return false;
+  }
+  if (NO_RESPONSE_ONLY_RE.test(trimmed)) {
+    return false;
+  }
+  if (isPotentialNoResponsePrefix(trimmed)) {
+    return false;
+  }
+  return stripNoResponseMarkers(trimmed).length > 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/cli",
-  "version": "0.11.7-staging.2",
+  "version": "0.11.8-staging.1",
   "description": "CLI tools for vellum-assistant",
   "type": "module",
   "exports": {
@@ -22,7 +22,7 @@
     "format:check": "prettier --check .",
     "lint": "eslint",
     "lint:unused": "knip --include files,dependencies,unlisted",
-    "compile:check": "bun build --compile --external react-devtools-core src/index.ts --outfile /dev/null",
+    "compile:check": "bun build --compile src/index.ts --outfile /dev/null",
     "test": "bun test",
     "typecheck": "bunx tsc --noEmit"
   },
@@ -38,7 +38,8 @@
     "ink": "6.8.0",
     "nanoid": "5.1.7",
     "qrcode-terminal": "0.12.0",
-    "react": "19.2.6"
+    "react": "19.2.6",
+    "react-devtools-core": "7.0.1"
   },
   "bundledDependencies": [
     "@vellumai/avatar-manifest",

package/src/__tests__/assistant-client-platform-auth.test.ts

@@ -0,0 +1,219 @@
+/**
+ * Tests for AssistantClient's platform-managed (`cloud: "vellum"`) auth path.
+ * These entries have no guardian token on disk, so the client must authenticate
+ * with the stored platform credential instead of sending an anonymous request
+ * (which the platform answers with a bare 403).
+ */
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  test,
+} from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const testDir = mkdtempSync(join(tmpdir(), "client-platform-auth-test-"));
+const ORIGINAL_LOCKFILE_DIR = process.env.VELLUM_LOCKFILE_DIR;
+const ORIGINAL_CONFIG_HOME = process.env.XDG_CONFIG_HOME;
+const ORIGINAL_FETCH = globalThis.fetch;
+
+import { AssistantClient } from "../lib/assistant-client.js";
+import { saveAssistantEntry } from "../lib/assistant-config.js";
+import {
+  clearPlatformToken,
+  savePlatformToken,
+} from "../lib/platform-client.js";
+
+const PLATFORM_URL = "https://platform.example.com";
+const ASSISTANT_ID = "019d1e04-cb20-719a-b04b-310072904444";
+const ORG_ID = "org-abc";
+
+/** Seed a platform-managed lockfile entry, optionally with a stored token. */
+function seedCloud(token?: string): void {
+  saveAssistantEntry({
+    assistantId: ASSISTANT_ID,
+    name: "Credence",
+    runtimeUrl: PLATFORM_URL,
+    cloud: "vellum",
+    species: "vellum",
+  });
+  if (token) {
+    savePlatformToken(token);
+  }
+}
+
+interface Call {
+  url: string;
+  headers: Record<string, string>;
+}
+
+/** Replace global fetch with a URL-routed stub; returns the call log. */
+function stubFetch(handler: (url: string, calls: Call[]) => Response): Call[] {
+  const calls: Call[] = [];
+  globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+    const url = typeof input === "string" ? input : String(input);
+    calls.push({
+      url,
+      headers: (init?.headers ?? {}) as Record<string, string>,
+    });
+    return handler(url, calls);
+  }) as typeof fetch;
+  return calls;
+}
+
+const isOrgFetch = (url: string) => url.includes("/v1/organizations/");
+const isRefresh = (url: string) => url.includes("/v1/guardian/refresh");
+
+function orgResponse(): Response {
+  return new Response(JSON.stringify({ results: [{ id: ORG_ID }] }), {
+    status: 200,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+describe("AssistantClient platform-managed auth", () => {
+  beforeEach(() => {
+    process.env.VELLUM_LOCKFILE_DIR = testDir;
+    process.env.XDG_CONFIG_HOME = testDir;
+    // Tests share testDir, so a token saved by an earlier one must not leak.
+    clearPlatformToken();
+  });
+
+  afterEach(() => {
+    globalThis.fetch = ORIGINAL_FETCH;
+    if (ORIGINAL_LOCKFILE_DIR === undefined) {
+      delete process.env.VELLUM_LOCKFILE_DIR;
+    } else {
+      process.env.VELLUM_LOCKFILE_DIR = ORIGINAL_LOCKFILE_DIR;
+    }
+    if (ORIGINAL_CONFIG_HOME === undefined) {
+      delete process.env.XDG_CONFIG_HOME;
+    } else {
+      process.env.XDG_CONFIG_HOME = ORIGINAL_CONFIG_HOME;
+    }
+  });
+
+  afterAll(() => {
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  test("sends X-Session-Token + Vellum-Organization-Id for a session token", async () => {
+    seedCloud("sess-tok-1");
+    const calls = stubFetch((url) =>
+      isOrgFetch(url) ? orgResponse() : new Response("", { status: 200 }),
+    );
+
+    const client = new AssistantClient({ assistantId: ASSISTANT_ID });
+    const res = await client.post("/messages/", { content: "hi" });
+
+    expect(res.status).toBe(200);
+    const assistantCall = calls.find((c) => !isOrgFetch(c.url))!;
+    expect(assistantCall.url).toBe(
+      `${PLATFORM_URL}/v1/assistants/${ASSISTANT_ID}/messages/`,
+    );
+    expect(assistantCall.headers["X-Session-Token"]).toBe("sess-tok-1");
+    expect(assistantCall.headers["Vellum-Organization-Id"]).toBe(ORG_ID);
+    expect(assistantCall.headers["Authorization"]).toBeUndefined();
+    expect(assistantCall.headers["Content-Type"]).toBe("application/json");
+  });
+
+  test("resolves the auth headers once across multiple requests", async () => {
+    seedCloud("sess-tok-2");
+    const calls = stubFetch((url) =>
+      isOrgFetch(url) ? orgResponse() : new Response("", { status: 200 }),
+    );
+
+    const client = new AssistantClient({ assistantId: ASSISTANT_ID });
+    await client.get("/healthz/");
+    await client.get("/healthz/");
+
+    expect(calls.filter((c) => isOrgFetch(c.url))).toHaveLength(1);
+    // A bodyless request must not claim a JSON body.
+    const assistantCalls = calls.filter((c) => !isOrgFetch(c.url));
+    expect(assistantCalls).toHaveLength(2);
+    expect(assistantCalls[0].headers["Content-Type"]).toBeUndefined();
+  });
+
+  test("sends a bearer Authorization and no org header for a vak_ API key", async () => {
+    seedCloud("vak_test_key");
+    const calls = stubFetch((url) =>
+      isOrgFetch(url) ? orgResponse() : new Response("", { status: 200 }),
+    );
+
+    const client = new AssistantClient({ assistantId: ASSISTANT_ID });
+    await client.get("/healthz/");
+
+    // API keys are already org-scoped, so no org lookup happens.
+    expect(calls.filter((c) => isOrgFetch(c.url))).toHaveLength(0);
+    const assistantCall = calls[0];
+    expect(assistantCall.headers["Authorization"]).toBe("Bearer vak_test_key");
+    expect(assistantCall.headers["Vellum-Organization-Id"]).toBeUndefined();
+    expect(assistantCall.headers["X-Session-Token"]).toBeUndefined();
+  });
+
+  test("throws the login hint instead of sending an anonymous request", async () => {
+    seedCloud(); // no platform token stored
+    const calls = stubFetch(() => new Response("", { status: 200 }));
+
+    const client = new AssistantClient({ assistantId: ASSISTANT_ID });
+
+    await expect(client.post("/messages/", { content: "hi" })).rejects.toThrow(
+      "Not logged in. Run `vellum login` first to authenticate with the platform.",
+    );
+    expect(calls).toHaveLength(0);
+  });
+
+  test("refuses to send platform credentials to a runtimeUrl override", async () => {
+    seedCloud("sess-tok-4");
+    const calls = stubFetch(() => new Response("", { status: 200 }));
+
+    expect(
+      () =>
+        new AssistantClient({
+          assistantId: ASSISTANT_ID,
+          runtimeUrl: "https://attacker.example.com",
+        }),
+    ).toThrow("Refusing to send platform credentials");
+    expect(calls).toHaveLength(0);
+  });
+
+  test("allows a runtimeUrl override that matches the entry's platform host", async () => {
+    seedCloud("sess-tok-5");
+    stubFetch((url) =>
+      isOrgFetch(url) ? orgResponse() : new Response("", { status: 200 }),
+    );
+
+    const client = new AssistantClient({
+      assistantId: ASSISTANT_ID,
+      runtimeUrl: `${PLATFORM_URL}/`, // trailing slash must not count as a mismatch
+    });
+
+    expect(client.runtimeUrl).toBe(PLATFORM_URL);
+    expect((await client.get("/healthz/")).status).toBe(200);
+  });
+
+  test("re-resolves the org id once on a 401 and never refreshes a guardian token", async () => {
+    seedCloud("sess-tok-3");
+    let assistantAttempts = 0;
+    const calls = stubFetch((url) => {
+      if (isOrgFetch(url)) {
+        return orgResponse();
+      }
+      assistantAttempts++;
+      return new Response("", { status: 401 }); // always 401
+    });
+
+    const client = new AssistantClient({ assistantId: ASSISTANT_ID });
+    const res = await client.get("/messages/");
+
+    expect(res.status).toBe(401);
+    expect(assistantAttempts).toBe(2); // original + one retry, no more
+    // The cached org id was invalidated, so the retry refetched it.
+    expect(calls.filter((c) => isOrgFetch(c.url))).toHaveLength(2);
+    expect(calls.filter((c) => isRefresh(c.url))).toHaveLength(0);
+  });
+});

package/src/__tests__/clean.test.ts

@@ -31,6 +31,7 @@ beforeAll(() => {
     detectOrphanedProcesses: detectOrphansMock,
   }));
   mock.module("../lib/process.js", () => ({
+    ...realProcess,
     stopProcess: stopProcessMock,
   }));
 });

package/src/__tests__/nginx-ingress.test.ts

@@ -72,7 +72,9 @@ import {
   hasIpv6Loopback,
   buildRemoteWebIndexHtml,
   cloudWebHubUrl,
+  MAX_PRESERVED_MODULE_PRELOADS,
   ensureTunnelEdge,
+  EDGE_TEMPLATE_VERSION,
   startRemoteWebIngress,
   stopContainerTunnelEdge,
   stopIngressNginx,
@@ -264,6 +266,56 @@ describe("buildIngressNginxConfig", () => {
     expect(remoteConf).toContain("location / {\n      return 404;\n    }");
   });
 
+  test("compresses text asset types", () => {
+    expect(remoteConf).toContain(
+      "gzip_types application/javascript application/json application/wasm image/svg+xml text/css text/plain;",
+    );
+  });
+
+  test("compresses only the static SPA surface, never a proxied response", () => {
+    // Compression is opt-in per location: this server also proxies
+    // authenticated /v1 and /webhooks traffic, and a compressed response
+    // carrying both a secret and attacker-influenced content over TLS is the
+    // BREACH side channel. The tuning at http scope stays inert.
+    expect(remoteConf).not.toMatch(/^ {2}gzip on;$/m);
+    const blocks = locationBlocks(remoteConf);
+    expect(
+      blocks
+        .filter((b) => b.body.includes("gzip on;"))
+        .map((b) => b.matcher)
+        .sort(),
+    ).toEqual([
+      "= /assistant/__remote-index.html",
+      "^~ /assistant/",
+      "^~ /assistant/assets/",
+    ]);
+    expect(
+      blocks
+        .filter(
+          (b) => b.body.includes("proxy_pass") && b.body.includes("gzip on;"),
+        )
+        .map((b) => b.matcher),
+    ).toEqual([]);
+  });
+
+  test("revalidates the shell and forbids storing only the inline config", () => {
+    const blocks = locationBlocks(remoteConf);
+    const cacheControlOf = (matcher: string) =>
+      blocks
+        .find((b) => b.matcher === matcher)
+        ?.body.match(/add_header Cache-Control "([^"]+)"/)?.[1];
+    expect(cacheControlOf("= /assistant/__remote-index.html")).toBe("no-cache");
+    expect(cacheControlOf("^~ /assistant/")).toBe("no-cache");
+    expect(cacheControlOf("^~ /assistant/assets/")).toBe(
+      "public, max-age=31536000, immutable",
+    );
+    // Only the inline __config return, which nginx gives no validator, still
+    // refuses storage. A second no-store means a revalidating location
+    // regressed to re-sending its whole body on every load.
+    expect(cacheControlOf("= /assistant/__config")).toBe("no-store");
+    expect(remoteConf.match(/no-store/g)).toHaveLength(1);
+  });
+
   test("serves remote web config for the SPA", () => {
     expect(remoteConf).toContain("location = /assistant/__config {");
     expect(remoteConf).toContain("default_type application/json;");
@@ -411,22 +463,61 @@ describe("buildRemoteWebIndexHtml", () => {
     expect(result).toContain("\\u003c/script\\u003e");
   });
 
-  test("drops modulepreload hints but keeps the entry script and stylesheet", () => {
+  test("keeps the consolidated boot graph's modulepreload hints", () => {
     const html = [
       "<html><head>",
       '<link rel="modulepreload" crossorigin href="/assistant/assets/a-1.js">',
       '<link rel="modulepreload" crossorigin href="/assistant/assets/b-2.js">',
-      '<link rel="stylesheet" crossorigin href="/assistant/assets/main-3.css">',
-      '<script type="module" crossorigin src="/assistant/assets/index-4.js"></script>',
+      '<link rel="modulepreload" crossorigin href="/assistant/assets/c-3.js">',
+      '<link rel="modulepreload" crossorigin href="/assistant/assets/d-4.js">',
+      '<link rel="stylesheet" crossorigin href="/assistant/assets/main-5.css">',
+      '<script type="module" crossorigin src="/assistant/assets/index-6.js"></script>',
+      "</head><body></body></html>",
+    ].join("\n");
+
+    const result = buildRemoteWebIndexHtml(html, { mode: "remote-gateway" });
+
+    expect(result.match(/rel="modulepreload"/g)).toHaveLength(4);
+    expect(result).toContain('href="/assistant/assets/a-1.js"');
+    expect(result).toContain('href="/assistant/assets/main-5.css"');
+    expect(result).toContain('src="/assistant/assets/index-6.js"');
+  });
+
+  test("strips a whole-graph preload set past the threshold, keeping entry and stylesheet", () => {
+    const preloads = Array.from(
+      { length: MAX_PRESERVED_MODULE_PRELOADS + 1 },
+      (_, i) =>
+        `<link rel="modulepreload" crossorigin href="/assistant/assets/chunk-${i}.js">`,
+    );
+    const html = [
+      "<html><head>",
+      ...preloads,
+      '<link rel="stylesheet" crossorigin href="/assistant/assets/main-x.css">',
+      '<script type="module" crossorigin src="/assistant/assets/index-y.js"></script>',
       "</head><body></body></html>",
     ].join("\n");
 
     const result = buildRemoteWebIndexHtml(html, { mode: "remote-gateway" });
 
     expect(result).not.toContain("modulepreload");
-    expect(result).not.toContain("/assistant/assets/a-1.js");
-    expect(result).toContain('href="/assistant/assets/main-3.css"');
-    expect(result).toContain('src="/assistant/assets/index-4.js"');
+    expect(result).not.toContain("/assistant/assets/chunk-0.js");
+    expect(result).toContain('href="/assistant/assets/main-x.css"');
+    expect(result).toContain('src="/assistant/assets/index-y.js"');
+  });
+
+  test("keeps exactly the threshold count of hints", () => {
+    const preloads = Array.from(
+      { length: MAX_PRESERVED_MODULE_PRELOADS },
+      (_, i) =>
+        `<link rel="modulepreload" crossorigin href="/assistant/assets/chunk-${i}.js">`,
+    );
+    const html = `<html><head>${preloads.join("\n")}</head><body></body></html>`;
+
+    const result = buildRemoteWebIndexHtml(html, { mode: "remote-gateway" });
+
+    expect(result.match(/rel="modulepreload"/g)).toHaveLength(
+      MAX_PRESERVED_MODULE_PRELOADS,
+    );
   });
 });
 
@@ -734,13 +825,37 @@ function mockUnkillableNginx(pid: number): void {
   installKillMock();
 }
 
+/**
+ * The multi-line `location <matcher> { ... }` blocks of a generated config,
+ * so a test can assert what a location does rather than how its lines are
+ * ordered. Single-line denylist locations carry no directives worth reading
+ * and are skipped by the trailing-brace match.
+ */
+function locationBlocks(
+  conf: string,
+): Array<{ matcher: string; body: string }> {
+  const blocks: Array<{ matcher: string; body: string }> = [];
+  const opener = /^ {4}location ([^{]+?) \{$/gm;
+  let match: RegExpExecArray | null;
+  while ((match = opener.exec(conf)) !== null) {
+    const end = conf.indexOf("\n    }", opener.lastIndex);
+    blocks.push({
+      matcher: match[1],
+      body: conf.slice(opener.lastIndex, end === -1 ? undefined : end),
+    });
+  }
+  return blocks;
+}
+
 const PRODUCTION_HUB_URL = "https://www.vellum.ai/assistant";
 
 /**
  * Mirror of the SPA config fingerprint the edge records in its ingress state
  * (sha256 over the edge template version and the injected config JSON). Pins
  * both the injected config shape and the hash format; assumes the
- * production-pinned environment. `template` tracks `EDGE_TEMPLATE_VERSION`.
+ * production-pinned environment. The version itself is imported rather than
+ * mirrored: bumping it is the correct response to any template edit, so a
+ * copy here would fail every such edit without naming a defect.
  */
 function spaConfigHash(
   opts: { assistantName?: string; assistantId?: string } = {},
@@ -748,7 +863,7 @@ function spaConfigHash(
   return createHash("sha256")
     .update(
       JSON.stringify({
-        template: 5,
+        template: EDGE_TEMPLATE_VERSION,
         config: {
           mode: "remote-gateway",
           apiBaseUrl: "/v1",

package/src/__tests__/retire-local.test.ts

@@ -33,14 +33,22 @@ const realNginxIngress = { ...(await import("../lib/nginx-ingress.js")) };
 const realRetireArchive = { ...(await import("../lib/retire-archive.js")) };
 
 const stopProcessByPidFileMock = mock(
-  async (_pidFile: string, _label: string): Promise<boolean> => true,
+  async (
+    _pidFile: string,
+    _label: string,
+    _extraCleanupFiles?: string[],
+    _timeoutMs?: number,
+  ): Promise<boolean> => true,
 );
+
+const { DAEMON_STOP_TIMEOUT_MS } = realProcess;
 const stopOrphanedDaemonProcessesMock = mock(
   async (_excludePids?: ReadonlySet<string>): Promise<boolean> => false,
 );
 const stopIngressNginxMock = mock(async (): Promise<boolean> => false);
 
 mock.module("../lib/process.js", () => ({
+  ...realProcess,
   stopProcessByPidFile: stopProcessByPidFileMock,
   stopOrphanedDaemonProcesses: stopOrphanedDaemonProcessesMock,
 }));
@@ -153,6 +161,29 @@ describe("retireLocal — CES sibling stop", () => {
     expect(gatewayStopCall).toBeDefined();
   });
 
+  // The daemon stops its own worker processes (schedule, route host, resource
+  // monitor, memory jobs) near the end of a long shutdown sequence. The 2s
+  // default in stopProcess would SIGKILL it first, stranding those workers as
+  // orphans that outlive the runtime that spawned them.
+  test("gives the daemon its full stop budget, not the default grace", async () => {
+    const entry = makeEntry("test-assistant");
+    await retireLocal("test-assistant", entry, {
+      progress: () => {},
+      log: () => {},
+      warn: () => {},
+      error: () => {},
+    });
+
+    const daemonStopCall = stopProcessByPidFileMock.mock.calls.find(
+      ([, label]) => label === "daemon",
+    );
+    expect(daemonStopCall?.[3]).toBe(DAEMON_STOP_TIMEOUT_MS);
+    // The budget is only meaningful if it outlasts the daemon's own 30s
+    // force-exit, which is what it is derived from. Anything at or below that
+    // kills the daemon before it can fold the WAL and hand off on its way out.
+    expect(DAEMON_STOP_TIMEOUT_MS).toBeGreaterThan(30_000);
+  });
+
   test("CES stop is a no-op when ces.pid is absent", async () => {
     // stopProcessByPidFile returns false when the PID file doesn't exist.
     // retireLocal should still complete successfully — the CES stop is best-effort.