dsh-perm-gate 4.1.3 → 4.2.0-beta.2

package/lib/config.d.ts

@@ -1,4 +1,5 @@
 import z from '@deepseek-ai/schemastery';
+import type { Volatile, VolatileSnapshot } from '@deepseek-ai/cosmokit';
 import type { RuleAction } from './rule.js';
 import { DEFAULT_GATE_PRESETS, resolveGatePresets } from './preset.js';
 /**
@@ -293,7 +294,125 @@ export declare function isRulesConfigured(value: unknown): boolean;
 export declare function readRulesFromSettings(scope: {
     get(): unknown;
 } | undefined): RulesConfig | undefined;
-export declare const Config: z<PermGateConfig>;
+export declare const Config: z<Schemastery.ObjectS<NoInfer<{
+    rulesFile: z<string, string, "plain">;
+    dshHome: z<string, string, "plain">;
+    defaultAction: z<"allow" | "ask" | "deny", "allow" | "ask" | "deny", "volatile-defined">;
+    caseInsensitivePaths: z<boolean, boolean, "volatile-defined">;
+    classifierEnabled: z<boolean, boolean, "volatile-defined">;
+    classifierEndpoint: z<string, string, "volatile">;
+    classifierModel: z<string, string, "volatile-defined">;
+    classifierApiKey: z<string, string, "volatile">;
+    riskTimeoutMs: z<number, number, "volatile-defined">;
+    riskLearning: z<boolean, boolean, "volatile-defined">;
+    riskSediment: z<boolean, boolean, "volatile-defined">;
+    classifierSource: z<"host" | "custom", "host" | "custom", "volatile-defined">;
+    classifierProvider: z<string, string, "volatile">;
+    riskThreshold: z<number, number, "volatile-defined">;
+    learningFile: z<string, string, "plain">;
+    eventsFile: z<string, string, "plain">;
+    grantTtlMs: z<number, number, "volatile-defined">;
+    grantMaxUses: z<number, number, "volatile-defined">;
+    permissive: z<boolean, boolean, "volatile-defined">;
+    gatePresets: z<string[], string[], "plain">;
+    permissiveStrategies: z<NoInfer<Schemastery.ObjectS<NoInfer<{
+        trustAutoAllow: z<boolean, boolean, "defined">;
+        alwaysConfirm: z<boolean, boolean, "defined">;
+        llmAssist: z<boolean, boolean, "defined">;
+        trustEscalation: z<boolean, boolean, "defined">;
+    }>>>, NoInfer<Schemastery.ObjectT<NoInfer<{
+        trustAutoAllow: z<boolean, boolean, "defined">;
+        alwaysConfirm: z<boolean, boolean, "defined">;
+        llmAssist: z<boolean, boolean, "defined">;
+        trustEscalation: z<boolean, boolean, "defined">;
+    }>>>, "volatile">;
+    allowlist: z<NoInfer<string[]>, NoInfer<string[]>, "volatile">;
+    denyKeywords: z<NoInfer<string[]>, NoInfer<string[]>, "volatile">;
+    autoAllowTools: z<NoInfer<string[]>, NoInfer<string[]>, "volatile">;
+    sessionSweep: z<boolean, boolean, "volatile-defined">;
+    workspaceStoreFile: z<string, string, "plain">;
+    searchUp: z<boolean, boolean, "volatile-defined">;
+    fallbackPath: z<string, string, "plain">;
+    badFilePolicy: z<"fail" | "warn", "fail" | "warn", "volatile-defined">;
+    maxChainLength: z<number, number, "volatile-defined">;
+    networkEnabled: z<boolean, boolean, "volatile-defined">;
+    networkMode: z<"deny-all" | "whitelist" | "allow-all", "deny-all" | "whitelist" | "allow-all", "volatile-defined">;
+    networkUnlisted: z<"ask" | "deny", "ask" | "deny", "volatile-defined">;
+    networkUnattributed: z<"allow" | "deny", "allow" | "deny", "volatile-defined">;
+    networkLoopback: z<"allow" | "policy", "allow" | "policy", "volatile-defined">;
+    networkBind: z<string, string, "volatile-defined">;
+    networkPort: z<number, number, "volatile-defined">;
+    networkNoProxy: z<"clear" | "preserve", "clear" | "preserve", "volatile-defined">;
+    networkInjectEnv: z<boolean, boolean, "volatile-defined">;
+    networkAskTimeoutMs: z<number, number, "volatile-defined">;
+    networkGrantTtlMs: z<number, number, "volatile-defined">;
+    rules: z<NoInfer<RulesConfig>, NoInfer<RulesConfig>, "volatile">;
+    watch: z<boolean, boolean, "defined">;
+    watchDebounceMs: z<number, number, "defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    rulesFile: z<string, string, "plain">;
+    dshHome: z<string, string, "plain">;
+    defaultAction: z<"allow" | "ask" | "deny", "allow" | "ask" | "deny", "volatile-defined">;
+    caseInsensitivePaths: z<boolean, boolean, "volatile-defined">;
+    classifierEnabled: z<boolean, boolean, "volatile-defined">;
+    classifierEndpoint: z<string, string, "volatile">;
+    classifierModel: z<string, string, "volatile-defined">;
+    classifierApiKey: z<string, string, "volatile">;
+    riskTimeoutMs: z<number, number, "volatile-defined">;
+    riskLearning: z<boolean, boolean, "volatile-defined">;
+    riskSediment: z<boolean, boolean, "volatile-defined">;
+    classifierSource: z<"host" | "custom", "host" | "custom", "volatile-defined">;
+    classifierProvider: z<string, string, "volatile">;
+    riskThreshold: z<number, number, "volatile-defined">;
+    learningFile: z<string, string, "plain">;
+    eventsFile: z<string, string, "plain">;
+    grantTtlMs: z<number, number, "volatile-defined">;
+    grantMaxUses: z<number, number, "volatile-defined">;
+    permissive: z<boolean, boolean, "volatile-defined">;
+    gatePresets: z<string[], string[], "plain">;
+    permissiveStrategies: z<NoInfer<Schemastery.ObjectS<NoInfer<{
+        trustAutoAllow: z<boolean, boolean, "defined">;
+        alwaysConfirm: z<boolean, boolean, "defined">;
+        llmAssist: z<boolean, boolean, "defined">;
+        trustEscalation: z<boolean, boolean, "defined">;
+    }>>>, NoInfer<Schemastery.ObjectT<NoInfer<{
+        trustAutoAllow: z<boolean, boolean, "defined">;
+        alwaysConfirm: z<boolean, boolean, "defined">;
+        llmAssist: z<boolean, boolean, "defined">;
+        trustEscalation: z<boolean, boolean, "defined">;
+    }>>>, "volatile">;
+    allowlist: z<NoInfer<string[]>, NoInfer<string[]>, "volatile">;
+    denyKeywords: z<NoInfer<string[]>, NoInfer<string[]>, "volatile">;
+    autoAllowTools: z<NoInfer<string[]>, NoInfer<string[]>, "volatile">;
+    sessionSweep: z<boolean, boolean, "volatile-defined">;
+    workspaceStoreFile: z<string, string, "plain">;
+    searchUp: z<boolean, boolean, "volatile-defined">;
+    fallbackPath: z<string, string, "plain">;
+    badFilePolicy: z<"fail" | "warn", "fail" | "warn", "volatile-defined">;
+    maxChainLength: z<number, number, "volatile-defined">;
+    networkEnabled: z<boolean, boolean, "volatile-defined">;
+    networkMode: z<"deny-all" | "whitelist" | "allow-all", "deny-all" | "whitelist" | "allow-all", "volatile-defined">;
+    networkUnlisted: z<"ask" | "deny", "ask" | "deny", "volatile-defined">;
+    networkUnattributed: z<"allow" | "deny", "allow" | "deny", "volatile-defined">;
+    networkLoopback: z<"allow" | "policy", "allow" | "policy", "volatile-defined">;
+    networkBind: z<string, string, "volatile-defined">;
+    networkPort: z<number, number, "volatile-defined">;
+    networkNoProxy: z<"clear" | "preserve", "clear" | "preserve", "volatile-defined">;
+    networkInjectEnv: z<boolean, boolean, "volatile-defined">;
+    networkAskTimeoutMs: z<number, number, "volatile-defined">;
+    networkGrantTtlMs: z<number, number, "volatile-defined">;
+    rules: z<NoInfer<RulesConfig>, NoInfer<RulesConfig>, "volatile">;
+    watch: z<boolean, boolean, "defined">;
+    watchDebounceMs: z<number, number, "defined">;
+}>>, "plain">;
+/** Live reference the 0.1.7 loader hands `apply` for `.volatile()` config fields. */
+export type VolatileRef<T> = Volatile<T>;
+/** The config fields marked `.volatile()` — live refs inside `apply`'s config. */
+export declare const VOLATILE_CONFIG_KEYS: readonly ["defaultAction", "caseInsensitivePaths", "classifierEnabled", "classifierEndpoint", "classifierModel", "classifierApiKey", "riskTimeoutMs", "riskLearning", "riskSediment", "classifierSource", "classifierProvider", "riskThreshold", "grantTtlMs", "grantMaxUses", "permissive", "permissiveStrategies", "allowlist", "denyKeywords", "autoAllowTools", "sessionSweep", "searchUp", "badFilePolicy", "maxChainLength", "networkEnabled", "networkMode", "networkUnlisted", "networkUnattributed", "networkLoopback", "networkBind", "networkPort", "networkNoProxy", "networkInjectEnv", "networkAskTimeoutMs", "networkGrantTtlMs", "rules"];
+/** Resolve one possibly-volatile field: a live ref on 0.1.7+, a plain value otherwise. */
+export declare function readVolatileValue<T>(value: T | Volatile<T> | undefined): VolatileSnapshot<T> | undefined;
+/** Shallow-resolve every volatile field into a plain snapshot (one per read). */
+export declare function resolveVolatileConfig(config: object): Record<string, unknown>;
 export type ResolvedPermGateConfig = Required<Pick<PermGateConfig, 'caseInsensitivePaths' | 'grantTtlMs' | 'grantMaxUses' | 'permissive' | 'riskTimeoutMs' | 'riskLearning' | 'riskThreshold'>> & Pick<PermGateConfig, 'rulesFile' | 'dshHome' | 'defaultAction' | 'classifierEnabled' | 'classifierEndpoint' | 'classifierModel' | 'classifierApiKey' | 'learningFile' | 'eventsFile'> & {
     readonly permissiveStrategies: PermissiveStrategies;
     readonly gatePresets: readonly string[];

package/lib/config.js

@@ -146,58 +146,94 @@ export function readRulesFromSettings(scope) {
 export const Config = z.object({
     rulesFile: z.string(),
     dshHome: z.string(),
-    defaultAction: z.union(['allow', 'ask', 'deny']).default('ask'),
-    caseInsensitivePaths: z.boolean().default(true),
-    classifierEnabled: z.boolean().default(false),
-    classifierEndpoint: z.string(),
-    classifierModel: z.string().default('deepseek-chat'),
-    classifierApiKey: z.string(),
-    riskTimeoutMs: z.number().min(1000).default(20_000),
-    riskLearning: z.boolean().default(true),
-    riskSediment: z.boolean().default(true),
-    classifierSource: z.union(['custom', 'host']).default('custom'),
-    classifierProvider: z.string(),
-    riskThreshold: z.number().min(1).max(10).default(1),
+    defaultAction: z.union(['allow', 'ask', 'deny']).default('ask').volatile(),
+    caseInsensitivePaths: z.boolean().default(true).volatile(),
+    classifierEnabled: z.boolean().default(false).volatile(),
+    classifierEndpoint: z.string().volatile(),
+    classifierModel: z.string().default('deepseek-chat').volatile(),
+    classifierApiKey: z.string().volatile(),
+    riskTimeoutMs: z.number().min(1000).default(20_000).volatile(),
+    riskLearning: z.boolean().default(true).volatile(),
+    riskSediment: z.boolean().default(true).volatile(),
+    classifierSource: z.union(['custom', 'host']).default('custom').volatile(),
+    classifierProvider: z.string().volatile(),
+    riskThreshold: z.number().min(1).max(10).default(1).volatile(),
     learningFile: z.string(),
     eventsFile: z.string(),
-    grantTtlMs: z.number().min(1).default(5 * 60_000),
-    grantMaxUses: z.number().min(1).default(1),
-    permissive: z.boolean().default(false),
+    grantTtlMs: z.number().min(1).default(5 * 60_000).volatile(),
+    grantMaxUses: z.number().min(1).default(1).volatile(),
+    permissive: z.boolean().default(false).volatile(),
     gatePresets: z.array(z.string()),
     permissiveStrategies: z.object({
         trustAutoAllow: z.boolean().default(true),
         alwaysConfirm: z.boolean().default(false),
         llmAssist: z.boolean().default(false),
         trustEscalation: z.boolean().default(true),
-    }),
-    allowlist: z.array(z.string()),
-    denyKeywords: z.array(z.string()),
-    autoAllowTools: z.array(z.string()),
-    sessionSweep: z.boolean().default(true),
+    }).volatile(),
+    allowlist: z.array(z.string()).volatile(),
+    denyKeywords: z.array(z.string()).volatile(),
+    autoAllowTools: z.array(z.string()).volatile(),
+    sessionSweep: z.boolean().default(true).volatile(),
     workspaceStoreFile: z.string(),
     // Rule chain (T1.9)
-    searchUp: z.boolean().default(false),
+    searchUp: z.boolean().default(false).volatile(),
     fallbackPath: z.string(),
-    badFilePolicy: z.union(['fail', 'warn']).default('fail'),
-    maxChainLength: z.number().min(1).max(50).default(10),
+    badFilePolicy: z.union(['fail', 'warn']).default('fail').volatile(),
+    maxChainLength: z.number().min(1).max(50).default(10).volatile(),
     // Network (Phase 2)
-    networkEnabled: z.boolean().default(false),
-    networkMode: z.union(['deny-all', 'whitelist', 'allow-all']).default('whitelist'),
-    networkUnlisted: z.union(['ask', 'deny']).default('ask'),
-    networkUnattributed: z.union(['allow', 'deny']).default('allow'),
-    networkLoopback: z.union(['allow', 'policy']).default('allow'),
-    networkBind: z.string().default('127.0.0.1'),
-    networkPort: z.number().min(0).max(65535).default(0),
-    networkNoProxy: z.union(['clear', 'preserve']).default('clear'),
-    networkInjectEnv: z.boolean().default(true),
-    networkAskTimeoutMs: z.number().min(1000).max(600_000).default(120_000),
-    networkGrantTtlMs: z.number().min(0).max(24 * 60 * 60_000).default(30 * 60_000),
+    networkEnabled: z.boolean().default(false).volatile(),
+    networkMode: z.union(['deny-all', 'whitelist', 'allow-all']).default('whitelist').volatile(),
+    networkUnlisted: z.union(['ask', 'deny']).default('ask').volatile(),
+    networkUnattributed: z.union(['allow', 'deny']).default('allow').volatile(),
+    networkLoopback: z.union(['allow', 'policy']).default('allow').volatile(),
+    networkBind: z.string().default('127.0.0.1').volatile(),
+    networkPort: z.number().min(0).max(65535).default(0).volatile(),
+    networkNoProxy: z.union(['clear', 'preserve']).default('clear').volatile(),
+    networkInjectEnv: z.boolean().default(true).volatile(),
+    networkAskTimeoutMs: z.number().min(1000).max(600_000).default(120_000).volatile(),
+    networkGrantTtlMs: z.number().min(0).max(24 * 60 * 60_000).default(30 * 60_000).volatile(),
+    // 0.1.7: the rules document lives on this entry as a volatile whole-object
+    // field (a second settings namespace is no longer projectable). Unconfigured
+    // (bare defaults) -> the rules file remains the source.
+    rules: RulesSchema.volatile(),
     // Hot reload (Phase 3)
     watch: z.boolean().default(false),
     watchDebounceMs: z.number().min(50).max(5000).default(300),
 });
+/** The config fields marked `.volatile()` — live refs inside `apply`'s config. */
+export const VOLATILE_CONFIG_KEYS = [
+    'defaultAction', 'caseInsensitivePaths', 'classifierEnabled', 'classifierEndpoint',
+    'classifierModel', 'classifierApiKey', 'riskTimeoutMs', 'riskLearning', 'riskSediment',
+    'classifierSource', 'classifierProvider', 'riskThreshold', 'grantTtlMs', 'grantMaxUses',
+    'permissive', 'permissiveStrategies', 'allowlist', 'denyKeywords', 'autoAllowTools',
+    'sessionSweep', 'searchUp', 'badFilePolicy', 'maxChainLength',
+    'networkEnabled', 'networkMode', 'networkUnlisted', 'networkUnattributed', 'networkLoopback',
+    'networkBind', 'networkPort', 'networkNoProxy', 'networkInjectEnv', 'networkAskTimeoutMs',
+    'networkGrantTtlMs', 'rules',
+];
+/** Resolve one possibly-volatile field: a live ref on 0.1.7+, a plain value otherwise. */
+export function readVolatileValue(value) {
+    if (value !== null && typeof value === 'object' && typeof value.get === 'function') {
+        return value.get();
+    }
+    return value;
+}
+/** Shallow-resolve every volatile field into a plain snapshot (one per read). */
+export function resolveVolatileConfig(config) {
+    const out = { ...config };
+    for (const key of VOLATILE_CONFIG_KEYS) {
+        const v = out[key];
+        if (v !== null && typeof v === 'object' && typeof v.get === 'function') {
+            out[key] = v.get();
+        }
+    }
+    return out;
+}
 export function resolveConfig(config = {}) {
-    const parsed = Config(config);
+    // 0.1.7: the apply-time config carries live refs for `.volatile()` fields —
+    // resolve them before validation; schemastery's own schema call also wraps
+    // volatile fields into fresh refs, so resolve the output as well.
+    const parsed = resolveVolatileConfig(Config(resolveVolatileConfig(config)));
     return {
         rulesFile: parsed.rulesFile,
         dshHome: parsed.dshHome,

package/lib/index.js

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { Config, RULES_NAMESPACE, RulesSchema, readRulesFromSettings, resolveDshHome, resolveDataDir, ensureDataDir, resolveGatePresets, resolvePermissiveStrategies, resolveRulesFile } from './config.js';
+import { Config, ensureDataDir, readRulesFromSettings, readVolatileValue, resolveVolatileConfig, resolveDshHome, resolveDataDir, resolveGatePresets, resolvePermissiveStrategies, resolveRulesFile } from './config.js';
 import { runDryRun } from './dry-run.js';
 import { registerDryRunRoute, registerEventsRoute, registerHealthRoute, registerLearningRoute, registerNetworkRoute, registerReceiverRoute, registerReviewRoutes, registerRulesRoute } from './events.js';
 import { buildReceiverInfo } from './receiver-info.js';
@@ -36,27 +36,6 @@ export { Config };
 const APPROVAL_OUTCOMES = new Set(['allowed-once', 'rejected', 'cancelled', 'unavailable']);
 /** Runtime settings namespace: `permissive` + `permissiveStrategies` (editable in the UI). */
 export const PERMISSIVE_NAMESPACE = 'dsh-perm-gate';
-/**
- * Inline equivalent of the official `installSettingsSection` helper: register
- * the namespace through the `settings` service, layer the composition entry as
- * `base`, and keep the runtime source live so the UI card applies immediately.
- * `onScope` receives the live scope after registration (for seeding/syncing
- * host-owned fields like the allowlist).
- */
-function installSettingsSection(ctx, ns, schema, entry, hooks) {
-    ;
-    ctx.inject(['settings'], (sctx) => {
-        const scope = sctx.settings.register(ns, schema, { base: entry });
-        hooks.setSource(() => scope.get());
-        hooks.onChange();
-        hooks.onScope?.(scope);
-        sctx.effect(() => () => {
-            hooks.setSource(() => entry);
-            hooks.onChange();
-        });
-        scope.watch(() => hooks.onChange());
-    });
-}
 /** Column a settings-scope value into the typed live face. */
 function asSurface(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value)
@@ -189,14 +168,14 @@ export function makePreExecuteListener(runtime) {
     };
 }
 export function apply(ctx, config = {}) {
-    // Runtime-adjustable config: the composition entry is the base; the settings
-    // namespace layers on top and `current()` always reads the active section.
-    let current = () => config;
-    // ─── Rules settings scope (dsh-perm-gate-rules namespace) ────────────────
-    // Holds the live settings-sourced rules document. When non-undefined, the
-    // runtime prefers it over the rules file on disk.
-    let rulesScope;
-    const readRulesDocument = () => readRulesFromSettings(rulesScope);
+    // Runtime-adjustable config: 0.1.7 hands `.volatile()` fields to apply() as
+    // live refs; `current()` shallow-resolves one snapshot per read.
+    const current = () => resolveVolatileConfig(config);
+    // ─── Rules (volatile `rules` field on this entry) ─────────────────────────
+    // The rules document is a `.volatile()` whole-object field of the plugin's
+    // own entry (0.1.7 has no second projectable namespace). Unconfigured
+    // (bare defaults) -> undefined -> the rules file stays the source.
+    const readRulesDocument = () => readRulesFromSettings({ get: () => readVolatileValue(config.rules) });
     // Plugin-owned data files live under $DSH_HOME (node_modules may be
     // read-only). The default resolves to `$DSH_HOME` / `~/.dsh`, so a profile
     // entry that omits `config` still records events, snapshots and learning.
@@ -429,54 +408,40 @@ export function apply(ctx, config = {}) {
     // the settings watch only ever runs on a later user action. Held in an
     // object so the mutable slots stay lint-clean and the intent is explicit.
     const networkRefs = {};
-    installSettingsSection(ctx, PERMISSIVE_NAMESPACE, Config, config, {
-        setSource: (source) => {
-            current = source;
-        },
-        onChange: () => { },
-        onScope: (scope) => {
-            // Seed the editable whitelist from the rules file only when the namespace
-            // carries no override yet, so the card shows the current allow patterns.
-            const surface = asSurface(scope.get());
-            if (surface !== undefined && !Array.isArray(surface.allowlist)) {
-                const patterns = runtime.allowlist();
-                if (patterns.length > 0)
-                    void scope.update({ allowlist: patterns.slice() });
+    // ─── 0.1.7 declarative settings ───────────────────────────────────────────
+    // The volatile fields render the settings form and arrive as live refs;
+    // each committed edit raises ONE `loader/volatile-update` (no remount).
+    // The host no longer seeds settings (there is no write path): an empty
+    // `allowlist` keeps the rules-file default via `runtime.allowlist()`.
+    let lastRulesDocKey;
+    ctx.on('loader/volatile-update', () => {
+        const next = asSurface(current());
+        if (next !== undefined) {
+            if (Array.isArray(next.allowlist)) {
+                runtime.setAllowlist(next.allowlist.filter((x) => typeof x === 'string'));
             }
-            // Card edits -> namespace -> rulesFile (mirror + reload).
-            scope.watch(() => {
-                const next = asSurface(scope.get());
-                if (next !== undefined && Array.isArray(next.allowlist)) {
-                    runtime.setAllowlist(next.allowlist.filter((x) => typeof x === 'string'));
-                }
-                // A network knob changed: re-mount the proxy so the card's switches
-                // take effect without a plugin reload. Only a rebind-relevant edit
-                // triggers it.
-                const key = networkKeyOf(next);
-                if (networkRefs.appliedKey !== undefined && networkRefs.appliedKey !== key) {
-                    networkRefs.appliedKey = key;
-                    networkRefs.rebind?.();
-                }
-                else if (networkRefs.appliedKey === undefined) {
-                    networkRefs.appliedKey = key;
-                }
-            });
-        },
-    });
-    // ─── Rules settings namespace (dsh-perm-gate-rules) ─────────────────────
-    // Registers the rules document in its own DSH settings namespace so the gate
-    // loads rules from settings (when configured) instead of the rules file.
-    installSettingsSection(ctx, RULES_NAMESPACE, RulesSchema, {}, {
-        setSource: (source) => {
-            rulesScope = { get: source };
-        },
-        onChange: () => { },
-        onScope: (scope) => {
-            rulesScope = scope;
-            // When rules change in settings, reload the runtime so the new ruleset
-            // takes effect on the next tool call.
-            scope.watch(() => { runtime.reload(); });
-        },
+            // A network knob changed: re-mount the proxy so the card's switches
+            // take effect without a plugin reload. Only a rebind-relevant edit
+            // triggers it.
+            const key = networkKeyOf(next);
+            if (networkRefs.appliedKey !== undefined && networkRefs.appliedKey !== key) {
+                networkRefs.appliedKey = key;
+                networkRefs.rebind?.();
+            }
+            else if (networkRefs.appliedKey === undefined) {
+                networkRefs.appliedKey = key;
+            }
+        }
+        // A rules edit reloads the runtime so the new ruleset takes effect on the
+        // next tool call (allowlist/network edits must not pay for a reload).
+        const rulesDoc = readRulesDocument();
+        const rulesKey = rulesDoc === undefined ? '' : JSON.stringify(rulesDoc);
+        if (rulesKey !== lastRulesDocKey) {
+            const changed = lastRulesDocKey !== undefined;
+            lastRulesDocKey = rulesKey;
+            if (changed)
+                runtime.reload();
+        }
     });
     // Event feed HTTP API (best effort): the dsh webServer service exposes the
     // JSONL decision events to the browser half; without it events stay on disk.

package/package.json

@@ -1,10 +1,8 @@
 {
   "name": "dsh-perm-gate",
-  "version": "4.1.3",
+  "version": "4.2.0-beta.2",
   "publishConfig": {
-    "registry": "https://registry.npmjs.org",
-    "access": "public",
-    "tag": "dsh-0.1.5"
+    "tag": "dsh-0.1.7"
   },
   "description": "DSH permission-gate for the DeepSeek Harness 0.1.5 line: a single self-sufficient, deterministic-first, fail-closed gate covering P0 hard-deny -> P1 session grant -> P2 static rule (allow/deny) chain -> P3 optional LLM semantic classifier -> P4 ask, with command whitelist/blacklist.",
   "type": "module",
@@ -67,32 +65,25 @@
   },
   "engines": {
     "node": ">=24",
-    "dsh": ">=0.1.5-rc.1 <0.1.6-0"
+    "dsh": ">=0.1.7-rc.1 <0.1.8-0"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-client-locale": ">=0.1.5-rc.1 <0.1.6-0",
-    "@deepseek-ai/dsh-client-ui-settings": ">=0.1.5-rc.1 <0.1.6-0",
-    "@deepseek-ai/dsh-client-ui-renderer": ">=0.1.5-rc.1 <0.1.6-0",
-    "@deepseek-ai/dsh-client-ui-conversation": ">=0.1.5-rc.1 <0.1.6-0"
-  },
-  "peerDependenciesMeta": {
-    "@deepseek-ai/dsh-client-locale": { "optional": true },
-    "@deepseek-ai/dsh-client-ui-settings": { "optional": true },
-    "@deepseek-ai/dsh-client-ui-renderer": { "optional": true },
-    "@deepseek-ai/dsh-client-ui-conversation": { "optional": true }
+    "@deepseek-ai/dsh-client-locale": ">=0.1.7-rc.1 <0.1.8-0",
+    "@deepseek-ai/dsh-client-ui-renderer": ">=0.1.7-rc.1 <0.1.8-0",
+    "@deepseek-ai/dsh-client-ui-settings": ">=0.1.7-rc.1 <0.1.8-0"
   },
   "dependencies": {
-    "@deepseek-ai/schemastery": "^3.18.0",
+    "@deepseek-ai/schemastery": "^3.18.4",
     "chokidar": "^5.0.0",
     "yaml": "^2.5.0"
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-client-locale": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-ui-renderer": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-ui-settings": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-ui-slots": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-client-locale": "^0.1.7-rc.1",
+    "@deepseek-ai/dsh-client-ui-renderer": "^0.1.7-rc.1",
+    "@deepseek-ai/dsh-client-ui-settings": "^0.1.7-rc.1",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.7-rc.1",
     "@eslint/js": "^10.0.1",
     "@types/node": "^22.0.0",
     "@types/react": "~18.3.1",
@@ -151,5 +142,16 @@
       ],
       "platform": "web"
     }
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-client-locale": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-ui-renderer": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-ui-settings": {
+      "optional": true
+    }
   }
 }