dsh-perm-gate 4.2.0-beta.4 → 4.2.0-beta.6

package/lib/config.d.ts

@@ -277,14 +277,17 @@ export interface RulesConfig {
     readonly deny?: unknown[];
     readonly allow?: unknown[];
     readonly ask?: unknown[];
+    /** Activation-time seed marker (see RulesSchema). */
+    readonly initialized?: boolean;
 }
 /** Settings namespace for rules (separate from the main perm-gate namespace). */
 export declare const RULES_NAMESPACE = "dsh-perm-gate-rules";
 /**
  * Whether a settings-sourced rules document carries a REAL configuration —
- * entries or a non-default `defaultAction`. A namespace still holding bare
- * schema defaults is "not configured" and must not shadow the rules file
- * (the dual-source contract: settings first, file fallback).
+ * entries, a non-default `defaultAction`, or the `initialized` marker the
+ * activation-time seed writes after populating an empty document. A namespace
+ * still holding bare schema defaults is "not configured" and must not shadow
+ * the rules file (the dual-source contract: settings first, file fallback).
  */
 export declare function isRulesConfigured(value: unknown): boolean;
 /**

package/lib/config.js

@@ -113,19 +113,26 @@ export const RulesSchema = z.object({
     deny: z.array(RuleEntrySchema).default([]),
     allow: z.array(RuleEntrySchema).default([]),
     ask: z.array(RuleEntrySchema).default([]),
+    // Activation-time seed marker: the gate writes `true` the first time it
+    // populates an empty document (file migration or bare starter), so the
+    // seeded namespace becomes the rules source instead of shadowing nothing.
+    initialized: z.boolean().default(false),
 });
 /** Settings namespace for rules (separate from the main perm-gate namespace). */
 export const RULES_NAMESPACE = 'dsh-perm-gate-rules';
 /**
  * Whether a settings-sourced rules document carries a REAL configuration —
- * entries or a non-default `defaultAction`. A namespace still holding bare
- * schema defaults is "not configured" and must not shadow the rules file
- * (the dual-source contract: settings first, file fallback).
+ * entries, a non-default `defaultAction`, or the `initialized` marker the
+ * activation-time seed writes after populating an empty document. A namespace
+ * still holding bare schema defaults is "not configured" and must not shadow
+ * the rules file (the dual-source contract: settings first, file fallback).
  */
 export function isRulesConfigured(value) {
     if (typeof value !== 'object' || value === null || Array.isArray(value))
         return false;
     const doc = value;
+    if (doc.initialized === true)
+        return true;
     if (doc.defaultAction !== undefined && doc.defaultAction !== 'ask')
         return true;
     for (const key of ['deny', 'allow', 'ask']) {

package/lib/index.js

@@ -1,6 +1,7 @@
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { Config, ensureDataDir, readRulesFromSettings, readVolatileValue, resolveVolatileConfig, resolveDshHome, resolveDataDir, resolveGatePresets, resolvePermissiveStrategies, resolveRulesFile } from './config.js';
+import { appendAllowToSettings, readRulesFileDoc, replaceAllowInSettings } from './allowlist.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';
@@ -176,10 +177,49 @@ export function apply(ctx, config = {}) {
     // 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) });
+    // ─── Host settings seam (allowlist write-back) ────────────────────────────
+    // The `settings` service mutates this entry's own config in the active
+    // profile patch (agent-default-model injects the same service). Its writes
+    // land in the `rules` volatile field, whose change watcher below reloads the
+    // runtime — so an "allow always" / allowlist edit takes effect on the next
+    // tool call even when the rules document (not the file) is the live source.
+    // The inject is a child effect: a host without the settings service leaves
+    // the ref unset and the runtime falls back to its rules-file write paths.
+    const ENTRY_ID = 'dsh-perm-gate';
+    const settingsRef = {};
+    ctx.inject(['settings'], (child) => {
+        const svc = child.settings;
+        settingsRef.svc = svc;
+        // Activation-time seed: a never-configured `rules` field is populated once
+        // — from the rules file when one exists (implicit migration), otherwise a
+        // bare starter document — and marked `initialized`, so the panel shows a
+        // live rules document from the first boot instead of a missing-file
+        // fallback. The field watcher below picks the seed up via reload.
+        if (svc !== undefined && readRulesDocument() === undefined) {
+            const seed = { ...readRulesFileDoc(rulesFilePath), initialized: true };
+            void svc.update(ENTRY_ID, { rules: seed }).catch((e) => {
+                console.warn('[dsh-perm-gate] rules seed write failed:', e);
+            });
+        }
+    });
+    const settingsWrite = (write) => {
+        const svc = settingsRef.svc;
+        if (svc === undefined)
+            return false;
+        const scope = {
+            get: () => readVolatileValue(config.rules),
+            update: async (section) => { await svc.update(ENTRY_ID, { rules: section }); },
+        };
+        void write(scope, readRulesFileDoc(rulesFilePath)).catch((e) => {
+            console.warn('[dsh-perm-gate] settings rules write failed:', e);
+        });
+        return true;
+    };
     // 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.
     const dataDir = resolveDataDir(typeof config.dshHome === 'string' ? config.dshHome : undefined);
+    const rulesFilePath = resolveRulesFile(typeof config.rulesFile === 'string' ? config.rulesFile : undefined, dataDir);
     // Host model-group services (typed minimally; supplied by the dsh runtime
     // through the loader `inject` — dsh-approval-gate demonstrates the same
     // contract). The llm service backs the `host` receiver; agentDefaultModel
@@ -321,9 +361,16 @@ export function apply(ctx, config = {}) {
         // The rules document lives in the plugin's data dir by default, so a
         // `$DSH_HOME/perm-gate/rules.yml` the user writes is actually loaded without
         // also having to declare `rulesFile` in the composition entry.
-        rulesFile: resolveRulesFile(typeof config.rulesFile === 'string' ? config.rulesFile : undefined, dataDir),
+        rulesFile: rulesFilePath,
         // Settings-sourced rules take precedence over the file when present.
         readRulesDocument,
+        // Allowlist write-back through the settings service (this entry's own
+        // `rules` config field, seeded from the file document on first write);
+        // a falsy verdict (service not wired) falls back to the rules file.
+        allowlistWriter: {
+            append: (pattern, reason) => settingsWrite((scope, seed) => appendAllowToSettings(scope, pattern, reason, seed)),
+            replace: (patterns, reason) => settingsWrite((scope, seed) => replaceAllowInSettings(scope, patterns, reason, seed)),
+        },
         // The whole gate is scoped to the presets that opt into it (default: the
         // `permissive` tier this plugin adds); elsewhere it stands down entirely.
         gatePresets: resolveGatePresets(Array.isArray(config.gatePresets) ? config.gatePresets : undefined),
@@ -505,9 +552,8 @@ export function apply(ctx, config = {}) {
             });
             if (offDryRun !== undefined)
                 ctx.effect(() => () => { offDryRun(); }, 'dsh-perm-gate: dry-run route');
-            // Permissions view: prefer the settings namespace (dsh-perm-gate-rules)
-            // when it carries a real configuration; fall back to the rules file.
-            const rulesFilePath = resolveRulesFile(typeof config.rulesFile === 'string' ? config.rulesFile : undefined, dataDir);
+            // Permissions view: prefer the entry's `rules` config field when it
+            // carries a real configuration; fall back to the rules file.
             const offRules = registerRulesRoute(webServer, {
                 view: () => {
                     const settingsDoc = readRulesDocument();

package/lib/rules-view.d.ts

@@ -37,7 +37,7 @@ export interface RulesView {
  */
 export declare function readRulesView(rulesFile: string): RulesView;
 /** The pseudo-path a settings view reports (there is no file to name). */
-export declare const SETTINGS_RULES_VIEW_PATH = "settings:dsh-perm-gate-rules";
+export declare const SETTINGS_RULES_VIEW_PATH = "config:dsh-perm-gate#rules";
 /**
  * Render the settings-sourced rules for display — the read-only face of the
  * `dsh-perm-gate-rules` namespace, the twin of {@link readRulesView}.

package/lib/rules-view.js

@@ -79,7 +79,7 @@ export function readRulesView(rulesFile) {
     }
 }
 /** The pseudo-path a settings view reports (there is no file to name). */
-export const SETTINGS_RULES_VIEW_PATH = 'settings:dsh-perm-gate-rules';
+export const SETTINGS_RULES_VIEW_PATH = 'config:dsh-perm-gate#rules';
 /**
  * Render the settings-sourced rules for display — the read-only face of the
  * `dsh-perm-gate-rules` namespace, the twin of {@link readRulesView}.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-perm-gate",
-  "version": "4.2.0-beta.4",
+  "version": "4.2.0-beta.6",
   "publishConfig": {
     "tag": "dsh-0.1.7"
   },