@gethelio/proxy 0.13.0 → 0.14.0

package/dist/index.js

@@ -564,7 +564,7 @@ function rootConfigChecks(cfg, ctx) {
       ctx.addIssue({
         code: "custom",
         path: ["dashboard", "api_secret"],
-        message: 'dashboard.api_secret is required when any rule uses require_approval, any budget uses on_exceed: require_approval, or policies.flag_destructive or policies.on_tool_drift is "require_approval". Generate one with: `openssl rand -hex 32` and set it under `dashboard.api_secret` in your helio.yaml. (See docs/approvals.md.)'
+        message: 'dashboard.api_secret is required when any rule uses require_approval, any budget uses on_exceed: require_approval, or policies.flag_destructive or policies.on_tool_drift is "require_approval". Run `helio secret` and set the printed digest under `dashboard.api_secret` in your helio.yaml (a plaintext value is accepted but warned about at startup). (See docs/approvals.md.)'
       });
     }
   }
@@ -572,7 +572,7 @@ function rootConfigChecks(cfg, ctx) {
     ctx.addIssue({
       code: "custom",
       path: ["dashboard", "api_secret"],
-      message: "dashboard.api_secret is required when dashboard.enabled is true unless dashboard.allow_open_mode is explicitly set to true. Generate one with `openssl rand -hex 32` and set it under dashboard.api_secret in helio.yaml."
+      message: "dashboard.api_secret is required when dashboard.enabled is true unless dashboard.allow_open_mode is explicitly set to true. Run `helio secret` and set the printed digest under dashboard.api_secret in helio.yaml."
     });
   }
   if (!requiresSecret && cfg.dashboard.enabled && !hasSecret && cfg.dashboard.allow_open_mode && !isLoopbackHost(cfg.dashboard.host)) {
@@ -938,6 +938,7 @@ function isNamedConfig(config) {
 
 // src/config/loader.ts
 import { readFile } from "fs/promises";
+import { createHash } from "crypto";
 import yaml from "js-yaml";
 
 // src/util/format-zod-errors.ts
@@ -957,44 +958,53 @@ var ConfigError = class extends Error {
   }
 };
 var ENV_VAR_PATTERN = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
-function interpolateEnvVars(value, env = process.env) {
+function interpolateTracked(value, env, path, out) {
   if (typeof value === "string") {
-    return value.replace(ENV_VAR_PATTERN, (_match, varName) => {
+    let substitutions = 0;
+    const result = value.replace(ENV_VAR_PATTERN, (_match, varName) => {
       const envValue = env[varName];
       if (envValue === void 0) {
         throw new ConfigError(`Environment variable "${varName}" is not set`);
       }
+      substitutions += 1;
       return envValue;
     });
+    if (substitutions > 0 && out !== void 0) out.push(path.join("."));
+    return result;
   }
   if (Array.isArray(value)) {
-    return value.map((item) => interpolateEnvVars(item, env));
+    return value.map((item, index) => interpolateTracked(item, env, [...path, String(index)], out));
   }
   if (value !== null && typeof value === "object") {
     return Object.fromEntries(
       Object.entries(value).map(([k, v]) => [
         k,
-        interpolateEnvVars(v, env)
+        interpolateTracked(v, env, [...path, k], out)
       ])
     );
   }
   return value;
 }
-async function loadConfig(filePath, env) {
-  let raw;
+async function readConfigSource(filePath) {
+  let bytes;
   try {
-    raw = await readFile(filePath, "utf-8");
+    bytes = await readFile(filePath);
   } catch {
     throw new ConfigError(`Cannot read config file: ${filePath}`);
   }
+  const sha256 = createHash("sha256").update(bytes).digest("hex");
+  return { raw: bytes.toString("utf-8"), sha256 };
+}
+function parseConfigSource(source, filePath, env) {
   let parsed;
   try {
-    parsed = yaml.load(raw);
+    parsed = yaml.load(source.raw);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     throw new ConfigError(`YAML parse error in ${filePath}: ${message}`);
   }
-  const interpolated = interpolateEnvVars(parsed, env);
+  const interpolatedPaths = [];
+  const interpolated = interpolateTracked(parsed, env ?? process.env, [], interpolatedPaths);
   const result = helioConfigSchema.safeParse(interpolated);
   if (!result.success) {
     const details = formatZodErrors(result.error).map(
@@ -1006,9 +1016,27 @@ async function loadConfig(filePath, env) {
       details
     );
   }
-  return result.data;
+  return { config: result.data, interpolatedPaths };
+}
+async function loadConfigWithMeta(filePath, env) {
+  const source = await readConfigSource(filePath);
+  const { config, interpolatedPaths } = parseConfigSource(source, filePath, env);
+  return { config, sha256: source.sha256, interpolatedPaths };
+}
+async function loadConfig(filePath, env) {
+  return (await loadConfigWithMeta(filePath, env)).config;
 }
 
+// src/config/reload-outcomes.ts
+var POLICY_RELOAD_OUTCOMES = [
+  "applied",
+  "rejected_invalid",
+  "rejected_unroutable",
+  "rejected_budget_flush",
+  "rejected_pinned",
+  "watch_failed"
+];
+
 // src/config/watcher.ts
 import { watch } from "chokidar";
 
@@ -7292,6 +7320,7 @@ function clampInt(value, fallback, min, max) {
 // src/audit/store.ts
 var DRIFT_EVENT_DECISIONS_SQL = "('tool_drift', 'tool_drift_reverted')";
 var NON_TOOL_DECISIONS_SQL = "('tool_drift', 'tool_drift_reverted', 'rejected')";
+var POLICY_RELOAD_KIND_SQL = "'policy_reload'";
 var EXPORT_MAX_RECORDS = 1e4;
 var LIST_MAX_PAGE_SIZE = 1e3;
 var CREATE_TABLE_DDL = `
@@ -7325,7 +7354,8 @@ CREATE TABLE IF NOT EXISTS audit_records (
   metadata          TEXT,
   protocol_version  TEXT,
   created_at        TEXT NOT NULL,
-  upstream          TEXT
+  upstream          TEXT,
+  config_sha256     TEXT
 );
 `;
 var CREATE_INDEX_DDL = `
@@ -7338,6 +7368,7 @@ CREATE INDEX IF NOT EXISTS idx_audit_upstream_status_created_at ON audit_records
 CREATE INDEX IF NOT EXISTS idx_audit_record_kind     ON audit_records (record_kind);
 CREATE INDEX IF NOT EXISTS idx_audit_origin          ON audit_records (origin);
 CREATE INDEX IF NOT EXISTS idx_audit_upstream        ON audit_records (upstream);
+CREATE INDEX IF NOT EXISTS idx_audit_config_sha256   ON audit_records (config_sha256);
 `;
 var INSERT_SQL = `
 INSERT INTO audit_records (
@@ -7347,7 +7378,7 @@ INSERT INTO audit_records (
   upstream_http_status,
   total_duration_ms, approval_wait_ms, proxy_compute_ms,
   flagged_destructive, dry_run, record_kind, origin, metadata, protocol_version, created_at,
-  upstream
+  upstream, config_sha256
 ) VALUES (
   @id, @timestamp, @session_id, @session_source, @agent_id, @environment, @tool_name, @tool_input,
   @policy_decision, @block_reason, @matched_rule, @matched_rule_index, @evidence_chain, @approval_status,
@@ -7355,7 +7386,7 @@ INSERT INTO audit_records (
   @upstream_http_status,
   @total_duration_ms, @approval_wait_ms, @proxy_compute_ms,
   @flagged_destructive, @dry_run, @record_kind, @origin, @metadata, @protocol_version, @created_at,
-  @upstream
+  @upstream, @config_sha256
 )
 `;
 var REQUIRED_AUDIT_COLUMNS = [
@@ -7375,10 +7406,14 @@ var REQUIRED_AUDIT_COLUMNS = [
   // Same clean break, same unreleased cycle (issue #219): released users see
   // ONE break, at v0.12.0.
   "protocol_version",
-  // The one ratified exception to the clean break (issue #292): a
-  // v0.12.0-complete database missing ONLY this column is migrated in place
-  // by migrateAuditUpstreamColumn instead of failing the assertion.
-  "upstream"
+  // The ratified exception to the clean break (issue #292): a database that
+  // is complete except for this column is migrated in place by
+  // migrateAdditiveAuditColumns instead of failing the assertion.
+  "upstream",
+  // The second additive column under the same exception (issue #341): a
+  // v0.13 database missing only this one, or a v0.12.0 database missing
+  // both, migrates in place; anything older still clean-breaks.
+  "config_sha256"
 ];
 function deserializeRow(row) {
   return {
@@ -7411,6 +7446,7 @@ function deserializeRow(row) {
     metadata: row.metadata ? JSON.parse(row.metadata) : null,
     protocol_version: row.protocol_version,
     upstream: row.upstream,
+    config_sha256: row.config_sha256,
     created_at: row.created_at
   };
 }
@@ -7491,21 +7527,34 @@ function buildWhereClause(filters) {
   const clause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
   return { clause, params };
 }
-function migrateAuditUpstreamColumn(db) {
+var ADDITIVE_AUDIT_COLUMNS = [
+  { name: "upstream", ddl: "upstream TEXT" },
+  { name: "config_sha256", ddl: "config_sha256 TEXT" }
+];
+function migrateAdditiveAuditColumns(db) {
   const probe = () => {
     const rows = db.pragma("table_info(audit_records)");
     return new Set(rows.map((row) => row.name));
   };
   const existing = probe();
-  const missing = REQUIRED_AUDIT_COLUMNS.filter((name) => !existing.has(name));
-  if (missing.length !== 1 || missing[0] !== "upstream") return false;
-  try {
-    db.exec("ALTER TABLE audit_records ADD COLUMN upstream TEXT");
-  } catch (err) {
-    if (probe().has("upstream")) return false;
-    throw err;
+  const missing = new Set(REQUIRED_AUDIT_COLUMNS.filter((name) => !existing.has(name)));
+  if (missing.size === 0) return [];
+  const additive = new Set(ADDITIVE_AUDIT_COLUMNS.map((column) => column.name));
+  for (const name of missing) {
+    if (!additive.has(name)) return [];
+  }
+  const added = [];
+  for (const column of ADDITIVE_AUDIT_COLUMNS) {
+    if (!missing.has(column.name)) continue;
+    try {
+      db.exec(`ALTER TABLE audit_records ADD COLUMN ${column.ddl}`);
+    } catch (err) {
+      if (probe().has(column.name)) continue;
+      throw err;
+    }
+    added.push(column.name);
   }
-  return true;
+  return added;
 }
 function restrictAuditFilePerms(dbPath) {
   if (dbPath === ":memory:" || process.platform === "win32") return;
@@ -7535,8 +7584,8 @@ var AuditStore = class {
     this.retentionMs = parseDuration(options.retention);
     this.includeResponses = options.includeResponses;
     this.db.exec(CREATE_TABLE_DDL);
-    if (migrateAuditUpstreamColumn(this.db)) {
-      console.error('[helio] Audit DB migrated: added column "upstream"');
+    for (const name of migrateAdditiveAuditColumns(this.db)) {
+      console.error(`[helio] Audit DB migrated: added column "${name}"`);
     }
     this.assertRequiredSchema(options.path);
     this.db.exec(CREATE_INDEX_DDL);
@@ -7647,6 +7696,7 @@ var AuditStore = class {
       metadata: record.metadata ? JSON.stringify(record.metadata) : null,
       protocol_version: record.protocol_version,
       upstream: record.upstream ?? null,
+      config_sha256: record.config_sha256 ?? null,
       created_at: now
     });
     return resolvedId;
@@ -7734,26 +7784,27 @@ var AuditStore = class {
     const totals = this.db.prepare(
       `SELECT
            COUNT(*) as total,
-           COALESCE(SUM(CASE WHEN block_reason IS NULL AND policy_decision NOT IN ${DRIFT_EVENT_DECISIONS_SQL} THEN 1 ELSE 0 END), 0) as allowed_total,
-           COALESCE(SUM(CASE WHEN block_reason IS NOT NULL THEN 1 ELSE 0 END), 0) as blocked_total,
-           COALESCE(SUM(CASE WHEN dry_run = 1 THEN 1 ELSE 0 END), 0) as dry_run_total,
-           COALESCE(SUM(CASE WHEN dry_run = 0 THEN 1 ELSE 0 END), 0) as applied_total
+           COALESCE(SUM(CASE WHEN block_reason IS NULL AND policy_decision NOT IN ${DRIFT_EVENT_DECISIONS_SQL} AND record_kind <> ${POLICY_RELOAD_KIND_SQL} THEN 1 ELSE 0 END), 0) as allowed_total,
+           COALESCE(SUM(CASE WHEN block_reason IS NOT NULL AND record_kind <> ${POLICY_RELOAD_KIND_SQL} THEN 1 ELSE 0 END), 0) as blocked_total,
+           COALESCE(SUM(CASE WHEN dry_run = 1 AND record_kind <> ${POLICY_RELOAD_KIND_SQL} THEN 1 ELSE 0 END), 0) as dry_run_total,
+           COALESCE(SUM(CASE WHEN dry_run = 0 AND record_kind <> ${POLICY_RELOAD_KIND_SQL} THEN 1 ELSE 0 END), 0) as applied_total
          FROM audit_records ${clause}`
     ).get(...params);
+    const decisionClause = clause ? `${clause} AND record_kind <> ${POLICY_RELOAD_KIND_SQL}` : `WHERE record_kind <> ${POLICY_RELOAD_KIND_SQL}`;
     const by_decision = this.db.prepare(
       `SELECT policy_decision as decision, COUNT(*) as count
-         FROM audit_records ${clause}
+         FROM audit_records ${decisionClause}
          GROUP BY policy_decision
          ORDER BY count DESC`
     ).all(...params);
-    const blockedClause = clause ? `${clause} AND block_reason IS NOT NULL` : "WHERE block_reason IS NOT NULL";
+    const blockedClause = clause ? `${clause} AND block_reason IS NOT NULL AND record_kind <> ${POLICY_RELOAD_KIND_SQL}` : `WHERE block_reason IS NOT NULL AND record_kind <> ${POLICY_RELOAD_KIND_SQL}`;
     const by_block_reason = this.db.prepare(
       `SELECT block_reason as reason, COUNT(*) as count
          FROM audit_records ${blockedClause}
          GROUP BY block_reason
          ORDER BY count DESC`
     ).all(...params);
-    const toolsClause = clause ? `${clause} AND policy_decision NOT IN ${NON_TOOL_DECISIONS_SQL}` : `WHERE policy_decision NOT IN ${NON_TOOL_DECISIONS_SQL}`;
+    const toolsClause = clause ? `${clause} AND policy_decision NOT IN ${NON_TOOL_DECISIONS_SQL} AND record_kind <> ${POLICY_RELOAD_KIND_SQL}` : `WHERE policy_decision NOT IN ${NON_TOOL_DECISIONS_SQL} AND record_kind <> ${POLICY_RELOAD_KIND_SQL}`;
     const top_tools = this.db.prepare(
       `SELECT tool_name, upstream, COUNT(*) as count
          FROM audit_records ${toolsClause}
@@ -7841,11 +7892,12 @@ var CSV_HEADERS = [
   "record_kind",
   "origin",
   "metadata",
-  // Appended LAST (issues #218, #219, #292): positional consumers of the
-  // existing columns keep working — new columns always go at the end.
+  // Appended LAST (issues #218, #219, #292, #341): positional consumers of
+  // the existing columns keep working — new columns always go at the end.
   "session_source",
   "protocol_version",
-  "upstream"
+  "upstream",
+  "config_sha256"
 ];
 var FORMULA_PREFIXES = /^[=+\-@\t\r]/;
 function csvEscape(value) {
@@ -8207,19 +8259,23 @@ import { HTTPException } from "hono/http-exception";
 import { z as z5 } from "zod";
 
 // src/auth/bearer.ts
-import { createHash, timingSafeEqual } from "crypto";
+import { createHash as createHash2, timingSafeEqual } from "crypto";
+var BEARER_PREFIX = "Bearer ";
+var DIGEST_PATTERN = /^sha256:([0-9a-f]{64})$/;
 function verifyBearer(authHeader, expected) {
   if (!authHeader || !expected) return false;
-  const expectedHeader = `Bearer ${expected}`;
-  const actualDigest = createHash("sha256").update(authHeader).digest();
-  const expectedDigest = createHash("sha256").update(expectedHeader).digest();
+  if (!authHeader.startsWith(BEARER_PREFIX)) return false;
+  const presented = authHeader.slice(BEARER_PREFIX.length);
+  const storedHex = DIGEST_PATTERN.exec(expected)?.[1];
+  const expectedDigest = storedHex !== void 0 ? Buffer.from(storedHex, "hex") : createHash2("sha256").update(expected, "utf-8").digest();
+  const actualDigest = createHash2("sha256").update(presented, "utf-8").digest();
   return timingSafeEqual(actualDigest, expectedDigest);
 }
 
 // src/sideband/governance-api.ts
 import { Hono as Hono4 } from "hono";
 import { z as z4 } from "zod";
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 var originSchema = z4.string().regex(/^[a-z0-9_-]{1,64}$/, "origin must match ^[a-z0-9_-]{1,64}$").default("sideband");
 var metadataSchema = z4.record(z4.string(), z4.unknown()).nullish();
 var toolDefinitionSchema = z4.object({
@@ -8376,7 +8432,7 @@ function auditPayloadHash(data) {
     actual_amount: data.actual_amount ?? null,
     evidence: canonicalEvidence(data.evidence)
   };
-  return createHash2("sha256").update(canonicalize(semantic)).digest("hex");
+  return createHash3("sha256").update(canonicalize(semantic)).digest("hex");
 }
 function canonicalEvidence(evidence) {
   if (!evidence || evidence.length === 0) return null;
@@ -9818,6 +9874,15 @@ var AuditWriter = class {
   bufferSize;
   onPush;
   onPersist;
+  /**
+   * The hash of the config file in force (issue #341), stamped onto every
+   * record whose builder left `config_sha256` nullish. Seeded at
+   * construction so no record is pushed unstamped before the first
+   * `setConfigSha256`; replaced by the reload path once the new policy is
+   * in force. Null only when the caller never had a hash (library
+   * embeddings without a config file).
+   */
+  configSha256;
   buffer = [];
   timer = null;
   flushSoonTimer = null;
@@ -9827,6 +9892,7 @@ var AuditWriter = class {
     this.bufferSize = options.bufferSize ?? 50;
     this.onPush = options.onPush;
     this.onPersist = options.onPersist;
+    this.configSha256 = options.configSha256 ?? null;
     const intervalMs = options.flushIntervalMs ?? 100;
     if (intervalMs > 0) {
       this.timer = setInterval(() => {
@@ -9847,8 +9913,9 @@ var AuditWriter = class {
    * is scheduled. This keeps request-path latency bounded even under bursty
    * write load.
    */
-  push(record, id = randomUUID6()) {
+  push(input, id = randomUUID6()) {
     if (this.closed) return;
+    const record = this.stamp(input);
     this.buffer.push({ id, record });
     this.onPush?.(record, id);
     if (this.buffer.length >= this.bufferSize) {
@@ -9863,12 +9930,30 @@ var AuditWriter = class {
    * A fatal-process crash still invokes the crash-drain hook, which calls
    * `flush()` synchronously before exit.
    */
-  pushImmediate(record, id = randomUUID6()) {
+  pushImmediate(input, id = randomUUID6()) {
     if (this.closed) return;
+    const record = this.stamp(input);
     this.buffer.push({ id, record });
     this.onPush?.(record, id);
     this.scheduleFlushSoon();
   }
+  /**
+   * Replace the config hash every later record is stamped with. Called by
+   * the reload path after the new policy is in force, before the reload's
+   * own record is pushed, so the reload record and every call it governs
+   * carry the new hash.
+   */
+  setConfigSha256(hash) {
+    this.configSha256 = hash;
+  }
+  /**
+   * Stamp the active config hash onto a record whose builder left the field
+   * nullish; a record that already carries a hash is passed through. The
+   * stamped record is what `onPush`, the store, and `onPersist` see.
+   */
+  stamp(record) {
+    return record.config_sha256 == null ? { ...record, config_sha256: this.configSha256 } : record;
+  }
   /**
    * Schedule a flush on the next tick, coalescing multiple calls into one.
    */
@@ -9964,6 +10049,25 @@ function buildHeaderMismatchAuditRecord(rejection, environment, upstream) {
   };
 }
 
+// src/audit/policy-reload.ts
+import { basename } from "path";
+import { z as z6 } from "zod";
+var policyReloadEvidenceSchema = z6.object({
+  outcome: z6.enum(POLICY_RELOAD_OUTCOMES),
+  config_path: z6.string(),
+  sha256_before: z6.string(),
+  sha256_after: z6.string().nullable(),
+  rule_count_before: z6.number(),
+  rule_count_after: z6.number().nullable(),
+  default_action_before: z6.enum(["allow", "deny"]),
+  default_action_after: z6.enum(["allow", "deny"]).nullable(),
+  budget_count_before: z6.number(),
+  budget_count_after: z6.number().nullable(),
+  rules_removed: z6.array(z6.string()),
+  restart_required_paths: z6.array(z6.string()),
+  error: z6.string().nullable()
+}).strict();
+
 // src/approval/queue.ts
 import { randomUUID as randomUUID7 } from "crypto";
 var ApprovalQueue = class {
@@ -10623,7 +10727,7 @@ function createChannels(channels) {
 // src/approval/slack-actions.ts
 import { createHmac as createHmac2, timingSafeEqual as timingSafeEqual2 } from "crypto";
 import { Hono as Hono6 } from "hono";
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var MAX_TIMESTAMP_AGE_S = 300;
 var REJECTION_LOG_WINDOW_MS = 6e4;
 var REJECTION_LOG_SAMPLE_EVERY = 25;
@@ -10689,12 +10793,12 @@ function verifySlackSignature(secrets, timestamp, rawBody, signature) {
   }
   return false;
 }
-var slackActionPayloadSchema = z6.object({
-  type: z6.string(),
-  user: z6.object({ id: z6.string(), username: z6.string() }),
-  actions: z6.array(z6.object({ action_id: z6.string() })),
-  channel: z6.object({ id: z6.string() }),
-  message: z6.object({ ts: z6.string() })
+var slackActionPayloadSchema = z7.object({
+  type: z7.string(),
+  user: z7.object({ id: z7.string(), username: z7.string() }),
+  actions: z7.array(z7.object({ action_id: z7.string() })),
+  channel: z7.object({ id: z7.string() }),
+  message: z7.object({ ts: z7.string() })
 });
 function parseActionPayload(rawBody) {
   try {
@@ -10824,17 +10928,17 @@ function createSlackActionApp(options) {
 
 // src/approval/api.ts
 import { Hono as Hono7 } from "hono";
-import { z as z7 } from "zod";
-var approveBody = z7.object({
-  approved_by: z7.string().min(1)
+import { z as z8 } from "zod";
+var approveBody = z8.object({
+  approved_by: z8.string().min(1)
 });
-var denyBody = z7.object({
-  denied_by: z7.string().min(1),
-  reason: z7.string().optional()
+var denyBody = z8.object({
+  denied_by: z8.string().min(1),
+  reason: z8.string().optional()
 });
-var breakGlassBody = z7.object({
-  approved_by: z7.string().min(1),
-  reason: z7.string().min(1)
+var breakGlassBody = z8.object({
+  approved_by: z8.string().min(1),
+  reason: z8.string().min(1)
 });
 var APPROVAL_STATUSES = [
   "pending",
@@ -10847,18 +10951,18 @@ var APPROVAL_STATUSES = [
   "cancelled"
 ];
 var approvalStatusSet = new Set(APPROVAL_STATUSES);
-var listApprovalsQuery = z7.object({
-  status: z7.preprocess(
+var listApprovalsQuery = z8.object({
+  status: z8.preprocess(
     (value) => typeof value === "string" && approvalStatusSet.has(value) ? value : void 0,
-    z7.enum(APPROVAL_STATUSES).optional()
+    z8.enum(APPROVAL_STATUSES).optional()
   ),
-  limit: z7.preprocess(
+  limit: z8.preprocess(
     (value) => clampInt(typeof value === "string" ? value : void 0, 50, 1, 1e3),
-    z7.number().int()
+    z8.number().int()
   ),
-  offset: z7.preprocess(
+  offset: z8.preprocess(
     (value) => clampInt(typeof value === "string" ? value : void 0, 0, 0, Number.MAX_SAFE_INTEGER),
-    z7.number().int()
+    z8.number().int()
   )
 });
 function createApprovalApp(router, queue, options) {
@@ -11000,25 +11104,25 @@ function createApprovalApp(router, queue, options) {
 // src/dashboard/api.ts
 import { readFileSync } from "fs";
 import { join } from "path";
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomBytes as randomBytes2, randomUUID as randomUUID8 } from "crypto";
 import { Hono as Hono8 } from "hono";
 import { HTTPException as HTTPException2 } from "hono/http-exception";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 import { cors } from "hono/cors";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { streamSSE } from "hono/streaming";
 
 // src/dashboard/session.ts
-import { createHash as createHash3, createHmac as createHmac3, randomBytes, timingSafeEqual as timingSafeEqual3 } from "crypto";
+import { createHash as createHash4, createHmac as createHmac3, randomBytes, timingSafeEqual as timingSafeEqual3 } from "crypto";
 var DashboardSessionStore = class {
-  secret;
+  signingKey;
   ttlMs;
   now;
   records = /* @__PURE__ */ new Map();
   timer = null;
   closed = false;
   constructor(options) {
-    this.secret = options.secret;
+    this.signingKey = options.signingKey;
     this.ttlMs = options.ttlMs ?? 8 * 60 * 60 * 1e3;
     this.now = options.now ?? Date.now;
     const cleanupIntervalMs = options.cleanupIntervalMs ?? 6e4;
@@ -11090,35 +11194,35 @@ var DashboardSessionStore = class {
     const id = token.slice(0, dot);
     const signature = token.slice(dot + 1);
     const expected = this.sign(id);
-    const actualDigest = createHash3("sha256").update(signature).digest();
-    const expectedDigest = createHash3("sha256").update(expected).digest();
+    const actualDigest = createHash4("sha256").update(signature).digest();
+    const expectedDigest = createHash4("sha256").update(expected).digest();
     if (!timingSafeEqual3(actualDigest, expectedDigest)) return void 0;
     return id;
   }
   sign(id) {
-    return createHmac3("sha256", this.secret).update(id).digest("base64url");
+    return createHmac3("sha256", this.signingKey).update(id).digest("base64url");
   }
 };
 
 // src/dashboard/api.ts
-var optionalQueryString = z8.preprocess(
+var optionalQueryString = z9.preprocess(
   (value) => typeof value === "string" && value.length > 0 ? value : void 0,
-  z8.string().optional()
+  z9.string().optional()
 );
-var optionalQueryInt = z8.preprocess((value) => {
+var optionalQueryInt = z9.preprocess((value) => {
   if (typeof value !== "string" || value.length === 0) return void 0;
   const parsed = Number.parseInt(value, 10);
   return Number.isFinite(parsed) ? parsed : void 0;
-}, z8.number().int().optional());
-var queryBoolean = z8.preprocess(
+}, z9.number().int().optional());
+var queryBoolean = z9.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : void 0,
-  z8.boolean().optional()
+  z9.boolean().optional()
 );
-var clampedQueryInt = (fallback, min, max) => z8.preprocess(
+var clampedQueryInt = (fallback, min, max) => z9.preprocess(
   (value) => clampInt(typeof value === "string" ? value : void 0, fallback, min, max),
-  z8.number().int()
+  z9.number().int()
 );
-var feedQuerySchema = z8.object({
+var feedQuerySchema = z9.object({
   limit: clampedQueryInt(50, 1, 200),
   offset: clampedQueryInt(0, 0, Number.MAX_SAFE_INTEGER),
   // The feed's server-side filters (issues #292, #316): attribution and
@@ -11128,8 +11232,8 @@ var feedQuerySchema = z8.object({
   upstream: optionalQueryString,
   session_source: optionalQueryString
 });
-var auditExportQuerySchema = z8.object({
-  format: z8.preprocess((value) => value === "csv" ? "csv" : "json", z8.enum(["json", "csv"])),
+var auditExportQuerySchema = z9.object({
+  format: z9.preprocess((value) => value === "csv" ? "csv" : "json", z9.enum(["json", "csv"])),
   limit: clampedQueryInt(EXPORT_MAX_RECORDS, 1, EXPORT_MAX_RECORDS),
   tool: optionalQueryString,
   decision: optionalQueryString,
@@ -11149,7 +11253,7 @@ var auditExportQuerySchema = z8.object({
   upstream: optionalQueryString,
   session_source: optionalQueryString
 });
-var auditQuerySchema = z8.object({
+var auditQuerySchema = z9.object({
   limit: clampedQueryInt(50, 1, LIST_MAX_PAGE_SIZE),
   offset: clampedQueryInt(0, 0, Number.MAX_SAFE_INTEGER),
   tool: optionalQueryString,
@@ -11171,21 +11275,21 @@ var auditQuerySchema = z8.object({
   upstream: optionalQueryString,
   session_source: optionalQueryString
 });
-var budgetEventsQuerySchema = z8.object({
+var budgetEventsQuerySchema = z9.object({
   limit: clampedQueryInt(50, 1, LIST_MAX_PAGE_SIZE),
   offset: clampedQueryInt(0, 0, Number.MAX_SAFE_INTEGER)
 });
-var budgetEventsExportQuerySchema = z8.object({
-  format: z8.preprocess((value) => value === "csv" ? "csv" : "json", z8.enum(["json", "csv"])),
+var budgetEventsExportQuerySchema = z9.object({
+  format: z9.preprocess((value) => value === "csv" ? "csv" : "json", z9.enum(["json", "csv"])),
   limit: clampedQueryInt(EXPORT_MAX_RECORDS, 1, EXPORT_MAX_RECORDS)
 });
-var analyticsQuerySchema = z8.object({
+var analyticsQuerySchema = z9.object({
   from: optionalQueryString,
   to: optionalQueryString,
   upstream: optionalQueryString
 });
-var authSessionBodySchema = z8.object({
-  secret: z8.string()
+var authSessionBodySchema = z9.object({
+  secret: z9.string()
 });
 var SESSION_COOKIE = "helio_session";
 var SESSION_TTL_MS = 8 * 60 * 60 * 1e3;
@@ -11258,7 +11362,10 @@ function createDashboardAppWithLifecycle(deps, options) {
     budgets
   } = deps;
   const apiSecret = options?.apiSecret;
-  const sessionStore = apiSecret ? new DashboardSessionStore({ secret: apiSecret, ttlMs: SESSION_TTL_MS }) : void 0;
+  const sessionStore = apiSecret ? new DashboardSessionStore({
+    signingKey: randomBytes2(32).toString("hex"),
+    ttlMs: SESSION_TTL_MS
+  }) : void 0;
   const app = new Hono8();
   app.onError((err, c) => {
     if (err instanceof HTTPException2) return err.getResponse();
@@ -11667,7 +11774,8 @@ var EVENT_TYPES = [
   "limit_warning",
   "approval_notification_failed",
   "budget_update",
-  "budget_breached"
+  "budget_breached",
+  "policy_reload"
 ];
 var DashboardEventBus = class {
   emitter = new EventEmitter();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gethelio/proxy",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "type": "module",
   "description": "Open-source MCP governance proxy for AI agents",
   "license": "Apache-2.0",
@@ -41,7 +41,7 @@
     "build": "pnpm run build:dashboard && pnpm run build:proxy && pnpm run bundle:dashboard-assets && pnpm run check:dashboard-assets",
     "test": "vitest run",
     "test:watch": "vitest",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc --noEmit && tsc -p scripts/tsconfig.json",
     "benchmark": "tsx scripts/benchmark.ts",
     "prepack": "pnpm run check:dashboard-assets"
   },