@khorsheed/dsh-context-guard 0.2.1 → 0.2.2

package/lib/index.js

@@ -3,8 +3,8 @@ import z from "@deepseek-ai/schemastery";
 /**
 * The settings namespace owned by the context-guard plugin. Plain string so
 * both the host half (settings registration) and the browser half
-* (settingsScope binding and the settings.plugin.item card key) import it
-* without dragging host-only dependencies into the client bundle.
+* (settingsScope binding and the 0.1.5 settings.plugin.item card key) import
+* it without dragging host-only dependencies into the client bundle.
 */
 /** Settings namespace owned by the context-guard plugin. */
 const CONTEXT_GUARD_NS = "context-guard";
@@ -12,38 +12,67 @@ const CONTEXT_GUARD_NS = "context-guard";
 //#region lib/types/settings.js
 /**
 * Host-side settings section of the context-guard plugin: the schemastery
-* schema that validates the `context-guard` settings namespace. The browser
-* half reads the resolved section through `ctx.settingsScope` and the
-* settings page renders it as a plugin card; the composition entry (the
-* cordis.yml row) becomes the section's `base` layer, so YAML values keep
+* schema of the `context-guard` configuration entry. rc.1's SettingsForms
+* serves the entry's own Config and edits only its volatile fields; 0.1.5
+* validates the legacy `settings.register` namespace with the same schema.
+* The browser half reads the resolved section through whichever settings
+* scope the line serves (see client/scope.ts); the composition entry (the
+* cordis.yml row) becomes the section's base layer, so YAML values keep
 * working as the defaults the card can override.
 *
 * These two fields tune ONLY when the compact button appears — the official
 * compaction engine (compaction-basic) reads its own `thresholdRatio` /
 * `maxTokens` config and never touches this section.
 */
-/** Section shape: the context-occupancy fraction at which the button appears. */
-const ContextGuardSettingsSchema = z.object({ thresholdRatio: z.number().min(.01).max(1).default(.8) });
+const thresholdField = z.number().min(.01).max(1).default(.8);
+/**
+* Section shape: the context-occupancy fraction at which the button appears.
+* The field is marked `.volatile()` when the running schemastery supports it
+* (3.18.4, host rc.1 — SettingsForms serves and edits ONLY volatile fields);
+* 0.1.5's schemastery (3.18.2) has no such method, the probe leaves the field
+* plain, and the legacy register path carries the section (the marker is
+* inert there). The inline probe (not a helper) keeps the emitted type
+* nameable under pnpm's layout.
+*/
+const ContextGuardSettingsSchema = z.object({ thresholdRatio: typeof thresholdField.volatile === "function" ? thresholdField.volatile() : thresholdField });
 //#endregion
 //#region lib/types/index.js
 /**
-* Context-guard plugin, node half. Registers the `context-guard` settings
-* namespace so the web settings page can render the compact-timing card and
-* the browser half can bind its `settingsScope` to the same section. The
-* plugin's own runtime behavior is purely client-side (the composer compact
-* button); this registration only exists to make the two tunables
-* (`thresholdRatio`, `maxTokens`) editable from the GUI instead of YAML.
+* Context-guard plugin, node half. Serves the `context-guard` settings
+* section so the web settings page can render the compact-timing card and
+* the browser half can bind its scope to the same section — on rc.1 through
+* the entry's own Config (below; SettingsForms serves and edits its volatile
+* field), on 0.1.5 through an explicit `settings.register` namespace whose
+* base layer is the composition entry. The plugin's own runtime behavior is
+* purely client-side (the composer compact button); this registration only
+* exists to make the two tunables (`thresholdRatio`, `maxTokens`) editable
+* from the GUI instead of YAML.
 * @module @khorsheed/dsh-context-guard
 */
 /**
-* Register the compact-timing section when a settings provider exists.
+* The entry Config: rc.1's SettingsForms serves exactly this schema under the
+* row id (`context-guard` — the settings namespace by construction) and
+* persists edits to its volatile field through the profile patch. On 0.1.5
+* the same schema validates the legacy namespace instead; the volatile
+* marker is probed at schema build time and simply absent there. The bare
+* `z` annotation keeps the emitted type nameable under pnpm's layout.
+*/
+const Config = ContextGuardSettingsSchema;
+/**
+* Serve the compact-timing section on whichever settings face the host line
+* carries.
 * @param ctx - Host context whose optional settings service owns the section.
-* @param config - the plugin's composition entry, used as the section's base layer.
+* @param config - the plugin's composition entry, the legacy path's base layer.
 */
 function apply(ctx, config = {}) {
 	ctx.inject(["settings"], (settingsCtx) => {
-		settingsCtx.settings.register(CONTEXT_GUARD_NS, ContextGuardSettingsSchema, { base: config });
+		const settings = settingsCtx.settings;
+		if (typeof settings.register === "function") {
+			settings.register(CONTEXT_GUARD_NS, ContextGuardSettingsSchema, { base: config });
+			return;
+		}
+		if (typeof settings.configure === "function") settings.configure({ auto: false }, ctx.fiber);
 	});
 }
 //#endregion
-export { CONTEXT_GUARD_NS, ContextGuardSettingsSchema, apply };
+export { CONTEXT_GUARD_NS, Config, ContextGuardSettingsSchema, apply };

package/lib/types/client/CompactGuardButton.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useMemo, useRef, useState } from 'react';
-import { IconWarningOutline16 } from '@deepseek-ai/dsh-client-ui-primitives';
+import { IconWarningOutlineMedium } from './icons.js';
 import { guardReading } from './guard.js';
 import css from './CompactGuardButton.module.css';
 /**
@@ -49,5 +49,5 @@ export function CompactGuardButton({ useProjection, useConfig, t, thresholdRatio
             setError(reason instanceof Error ? reason.message : String(reason));
         });
     };
-    return (_jsxs("span", { className: css.wrap, children: [_jsxs("button", { type: "button", className: `${css.button} ${css.warning}`, "aria-label": t('button.aria', { percent: String(reading.percent) }), disabled: busy, onClick: run, children: [_jsx("span", { className: css.icon, "aria-hidden": true, children: _jsx(IconWarningOutline16, { size: 14 }) }), t('button.label')] }), error !== null && (_jsx("span", { className: css.error, role: "status", title: error, children: t('button.error') }))] }));
+    return (_jsxs("span", { className: css.wrap, children: [_jsxs("button", { type: "button", className: `${css.button} ${css.warning}`, "aria-label": t('button.aria', { percent: String(reading.percent) }), disabled: busy, onClick: run, children: [_jsx("span", { className: css.icon, "aria-hidden": true, children: _jsx(IconWarningOutlineMedium, { size: 14 }) }), t('button.label')] }), error !== null && (_jsx("span", { className: css.error, role: "status", title: error, children: t('button.error') }))] }));
 }

package/lib/types/client/SettingsCard.d.ts

@@ -1,12 +1,17 @@
-import type { ContextGuardSettingsCardProps } from './slots.ts';
+import type { ContextGuardBundleConfigProps, ContextGuardSettingsCardProps } from './slots.ts';
 /**
- * The context-guard settings card in the plugin configuration tab: the same
- * collapsible chrome the official plugin cards use (a header naming the
+ * The context-guard settings card in the 0.1.5 plugin configuration tab: the
+ * same collapsible chrome the official plugin cards use (a header naming the
  * plugin and what its settings govern, disclosing the controls in place),
  * re-implemented here because the client bundle-purity gate forbids
- * value-importing the official card chrome. Two staged number fields write
- * through the shared settingsScope on save; per-field reset reverts a field
- * to the composition layer.
+ * value-importing the official card chrome.
  */
 export declare function ContextGuardSettingsCard({ useConfig, scope, t }: ContextGuardSettingsCardProps): import("react").JSX.Element | null;
+/**
+ * The bundle's configuration on the alpha.2 Plugins page
+ * (`plugins.bundle.config`, keyed by package name): the page draws the title,
+ * the icon, and the crumb itself, so the entry renders the one-liner for the
+ * `summary` view and the bare form — with its own save control — for `page`.
+ */
+export declare function ContextGuardBundleConfig({ view, useConfig, scope, t }: ContextGuardBundleConfigProps): import("react").JSX.Element | null;
 //# sourceMappingURL=SettingsCard.d.ts.map

package/lib/types/client/SettingsCard.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useRef, useState } from 'react';
-import { IconChevronDownOutline14 } from '@deepseek-ai/dsh-client-ui-primitives';
+import { IconChevronDownOutlineMedium } from './icons.js';
 import css from './SettingsCard.module.css';
 /** Parse a draft into a number, or NaN when it is not one. */
 function parseNumber(text) {
@@ -15,18 +15,11 @@ function overridden(snapshot, field) {
         && field in snapshot.user;
 }
 /**
- * The context-guard settings card in the plugin configuration tab: the same
- * collapsible chrome the official plugin cards use (a header naming the
- * plugin and what its settings govern, disclosing the controls in place),
- * re-implemented here because the client bundle-purity gate forbids
- * value-importing the official card chrome. Two staged number fields write
- * through the shared settingsScope on save; per-field reset reverts a field
- * to the composition layer.
+ * The staged threshold edit both settings surfaces share. Two staged number
+ * fields write through the shared settings scope on save; per-field reset
+ * reverts a field to the composition layer.
  */
-export function ContextGuardSettingsCard({ useConfig, scope, t }) {
-    const snapshot = useConfig(value => value);
-    const value = snapshot.status === 'ready' ? snapshot.value : undefined;
-    const [open, setOpen] = useState(false);
+function useThresholdDraft(scope, snapshot, value) {
     const [threshold, setThreshold] = useState({ text: '', invalid: false });
     const [saved, setSaved] = useState(false);
     const [error, setError] = useState(false);
@@ -53,8 +46,6 @@ export function ContextGuardSettingsCard({ useConfig, scope, t }) {
             aliveRef.current = false;
         };
     }, [value, snapshot.revision]);
-    if (snapshot.status === 'unavailable')
-        return null;
     const write = (draft, min, max) => {
         const parsed = parseNumber(draft.text);
         setThreshold({ text: draft.text, invalid: !Number.isFinite(parsed) || parsed < min || parsed > max });
@@ -85,13 +76,50 @@ export function ContextGuardSettingsCard({ useConfig, scope, t }) {
                 setError(true);
         });
     };
-    const title = t('settings.title');
+    const discard = () => {
+        if (value === undefined)
+            return;
+        setThreshold({ text: String(value.thresholdRatio), invalid: false });
+        setSaved(false);
+        setError(false);
+    };
     const dirty = threshold.text !== String(value?.thresholdRatio ?? '');
-    return (_jsxs("li", { className: open ? `${css.card} ${css.cardOpen}` : css.card, children: [_jsxs("button", { type: "button", className: css.header, "aria-expanded": open, "aria-label": `${t(open ? 'settings.collapse' : 'settings.expand')}: ${title}`, onClick: () => { setOpen(!open); }, children: [_jsxs("span", { className: css.headText, children: [_jsx("span", { className: css.name, children: title }), _jsx("span", { className: css.description, children: t('settings.description') })] }), _jsx(IconChevronDownOutline14, { className: open ? `${css.chevron} ${css.chevronOpen}` : css.chevron })] }), open && value !== undefined && (_jsxs("div", { className: css.body, children: [_jsxs("label", { className: css.field, children: [_jsxs("span", { className: css.fieldHead, children: [_jsx("span", { className: css.fieldName, children: t('settings.field.threshold') }), overridden(snapshot, 'thresholdRatio') && _jsx("span", { className: css.badge, children: t('settings.overridden') })] }), _jsxs("span", { className: css.inputRow, children: [_jsx("input", { className: threshold.invalid ? `${css.input} ${css.inputInvalid}` : css.input, type: "number", step: "0.01", min: "0.01", max: "1", value: threshold.text, "aria-label": t('settings.field.threshold'), onChange: (event) => { write({ text: event.target.value, invalid: false }, 0.01, 1); } }), _jsx("button", { type: "button", className: css.reset, onClick: reset, children: t('settings.reset') })] }), _jsx("span", { className: css.hint, children: t('settings.field.threshold.hint') })] }), _jsxs("span", { className: css.footer, children: [_jsxs("span", { className: css.status, children: [saved ? _jsx("span", { className: css.saved, children: t('settings.saved') }) : null, error ? _jsx("span", { className: css.errorText, children: t('settings.error') }) : null] }), _jsx("button", { type: "button", className: css.secondary, disabled: !dirty, onClick: () => {
-                                    if (value === undefined)
-                                        return;
-                                    setThreshold({ text: String(value.thresholdRatio), invalid: false });
-                                    setSaved(false);
-                                    setError(false);
-                                }, children: t('settings.discard') }), _jsx("button", { type: "button", className: css.save, disabled: !dirty || threshold.invalid || snapshot.writable !== true, onClick: save, children: t('settings.save') })] })] }))] }));
+    return { threshold, saved, error, dirty, write, save, reset, discard };
+}
+/** The threshold field row and the save/discard footer both settings surfaces render. */
+function SettingsBody({ snapshot, draft, t }) {
+    return (_jsxs("div", { className: css.body, children: [_jsxs("label", { className: css.field, children: [_jsxs("span", { className: css.fieldHead, children: [_jsx("span", { className: css.fieldName, children: t('settings.field.threshold') }), overridden(snapshot, 'thresholdRatio') && _jsx("span", { className: css.badge, children: t('settings.overridden') })] }), _jsxs("span", { className: css.inputRow, children: [_jsx("input", { className: draft.threshold.invalid ? `${css.input} ${css.inputInvalid}` : css.input, type: "number", step: "0.01", min: "0.01", max: "1", value: draft.threshold.text, "aria-label": t('settings.field.threshold'), onChange: (event) => { draft.write({ text: event.target.value, invalid: false }, 0.01, 1); } }), _jsx("button", { type: "button", className: css.reset, onClick: draft.reset, children: t('settings.reset') })] }), _jsx("span", { className: css.hint, children: t('settings.field.threshold.hint') })] }), _jsxs("span", { className: css.footer, children: [_jsxs("span", { className: css.status, children: [draft.saved ? _jsx("span", { className: css.saved, children: t('settings.saved') }) : null, draft.error ? _jsx("span", { className: css.errorText, children: t('settings.error') }) : null] }), _jsx("button", { type: "button", className: css.secondary, disabled: !draft.dirty, onClick: draft.discard, children: t('settings.discard') }), _jsx("button", { type: "button", className: css.save, disabled: !draft.dirty || draft.threshold.invalid || snapshot.writable !== true, onClick: draft.save, children: t('settings.save') })] })] }));
+}
+/**
+ * The context-guard settings card in the 0.1.5 plugin configuration tab: the
+ * same collapsible chrome the official plugin cards use (a header naming the
+ * plugin and what its settings govern, disclosing the controls in place),
+ * re-implemented here because the client bundle-purity gate forbids
+ * value-importing the official card chrome.
+ */
+export function ContextGuardSettingsCard({ useConfig, scope, t }) {
+    const snapshot = useConfig(value => value);
+    const value = snapshot.status === 'ready' ? snapshot.value : undefined;
+    const [open, setOpen] = useState(false);
+    const draft = useThresholdDraft(scope, snapshot, value);
+    if (snapshot.status === 'unavailable')
+        return null;
+    const title = t('settings.title');
+    return (_jsxs("li", { className: open ? `${css.card} ${css.cardOpen}` : css.card, children: [_jsxs("button", { type: "button", className: css.header, "aria-expanded": open, "aria-label": `${t(open ? 'settings.collapse' : 'settings.expand')}: ${title}`, onClick: () => { setOpen(!open); }, children: [_jsxs("span", { className: css.headText, children: [_jsx("span", { className: css.name, children: title }), _jsx("span", { className: css.description, children: t('settings.description') })] }), _jsx(IconChevronDownOutlineMedium, { className: open ? `${css.chevron} ${css.chevronOpen}` : css.chevron })] }), open && value !== undefined && _jsx(SettingsBody, { snapshot: snapshot, draft: draft, t: t })] }));
+}
+/**
+ * The bundle's configuration on the alpha.2 Plugins page
+ * (`plugins.bundle.config`, keyed by package name): the page draws the title,
+ * the icon, and the crumb itself, so the entry renders the one-liner for the
+ * `summary` view and the bare form — with its own save control — for `page`.
+ */
+export function ContextGuardBundleConfig({ view, useConfig, scope, t }) {
+    const snapshot = useConfig(value => value);
+    const value = snapshot.status === 'ready' ? snapshot.value : undefined;
+    const draft = useThresholdDraft(scope, snapshot, value);
+    if (view === 'summary')
+        return _jsx("span", { className: css.description, children: t('settings.description') });
+    if (snapshot.status === 'unavailable' || value === undefined)
+        return null;
+    return _jsx(SettingsBody, { snapshot: snapshot, draft: draft, t: t });
 }

package/lib/types/client/config.js

@@ -16,6 +16,18 @@ const THRESHOLD_RATIO_MAX = 1;
 function clamp(value, min, max) {
     return Math.min(max, Math.max(min, value));
 }
+/**
+ * Unwrap one maybe-Volatile config field. rc.1 resolves volatile-marked
+ * Config fields into live references (`{ get() }`); 0.1.5 passes the plain
+ * value. The schema's volatile marker is probed per line (see
+ * ../settings.ts), so BOTH shapes arrive depending on the host line.
+ */
+function unwrapVolatile(value) {
+    if (value !== null && typeof value === 'object' && typeof value.get === 'function') {
+        return value.get();
+    }
+    return value;
+}
 /**
  * Normalize the entry config into the full {@link ContextGuardConfig}: every
  * omitted field takes its documented default and every numeric field is
@@ -24,7 +36,8 @@ function clamp(value, min, max) {
  * @returns the effective guard behavior.
  */
 export function resolveConfig(config) {
+    const ratio = unwrapVolatile(config?.thresholdRatio);
     return {
-        thresholdRatio: clamp(config?.thresholdRatio ?? 0.8, THRESHOLD_RATIO_MIN, THRESHOLD_RATIO_MAX),
+        thresholdRatio: clamp(typeof ratio === 'number' ? ratio : 0.8, THRESHOLD_RATIO_MIN, THRESHOLD_RATIO_MAX),
     };
 }

package/lib/types/client/icons.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Generated by scripts/sync-icon-artwork.mts from @deepseek-ai/dsh-client-ui-primitives
+ * (v0.1.7-rc.1, harness 46a7f68b09) — do not edit by hand. The 0.1.5 and rc.1 host lines
+ * share no icon export name, so the rc.1 artwork is inlined here: pure SVG,
+ * no host runtime identity, identical on every line. Re-run the generator
+ * after adding an icon import or bumping the harness checkout.
+ *
+ * @module @khorsheed/dsh-context-guard/client
+ */
+/** Shared props for every product icon component (mirrors the upstream IconProps). */
+export interface IconProps {
+    /** Square edge in px; defaults to the glyph's own drawn size. */
+    size?: number | undefined;
+    /** Extra class for layout placement; color rides currentColor. */
+    className?: string | undefined;
+}
+export declare const IconChevronDownOutlineMedium: ({ size, className }: IconProps) => import("react").JSX.Element;
+export declare const IconWarningOutlineMedium: ({ size, className }: IconProps) => import("react").JSX.Element;
+//# sourceMappingURL=icons.d.ts.map

package/lib/types/client/icons.js

@@ -0,0 +1,3 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export const IconChevronDownOutlineMedium = ({ size = 14, className }) => (_jsx("svg", { width: size, height: size, className: className, viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": "true", strokeWidth: 1.3, children: _jsx("path", { d: "M4 6L7.29289 9.29289C7.68342 9.68342 8.31658 9.68342 8.70711 9.29289L12 6", stroke: "currentColor" }) }));
+export const IconWarningOutlineMedium = ({ size = 16, className }) => (_jsxs("svg", { width: size, height: size, className: className, viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": "true", strokeWidth: 1.3, children: [_jsx("path", { d: "M8 14.5C11.5899 14.5 14.5 11.5899 14.5 8C14.5 4.41015 11.5899 1.5 8 1.5C4.41015 1.5 1.5 4.41015 1.5 8C1.5 11.5899 4.41015 14.5 8 14.5Z", stroke: "currentColor" }), _jsx("path", { d: "M8 4.29199V9.79199", stroke: "currentColor" }), _jsx("path", { d: "M8 10.708V11.708", stroke: "currentColor" })] }));

package/lib/types/client/index.d.ts

@@ -3,13 +3,22 @@
  * `conversation.input.right` entry — a compact button inside the composer's
  * tool row that appears automatically when the next request's budget
  * (`contextPressure.projectedTokens` + the output budget) crosses
- * `thresholdRatio` of the routed model's context window — plus one
- * `settings.plugin.item` card in the plugin configuration tab that edits the
- * same two numbers live. The action rides the official `/compact` command
+ * `thresholdRatio` of the routed model's context window — plus one settings
+ * surface editing the same number live: a standalone install renders the
+ * bundle's own configuration on its Plugins-page detail view
+ * (`plugins.bundle.config`, keyed by package name), a family-bundle install
+ * renders the same card through the row-level configure entry on the
+ * BUNDLE's detail view (`plugins.row.config`, keyed
+ * `@khorsheed/dsh-bundle-conversation-toolbox#context-guard`), and 0.1.5
+ * renders the `settings.plugin.item` card in the plugin configuration tab
+ * (keyed by the settings namespace). The action
+ * rides the official `/compact` command
  * channel (`remote.commands.execute` → host `ctx.commands` →
  * `ctx.compaction.compactNow`); the config rides the official settings
- * surface (host half registers the namespace, this half binds its
- * `settingsScope`), so neither needs a new RPC or any edit to core packages;
+ * surface (the host half serves the section — its own Config on rc.1, a
+ * `settings.register` namespace on 0.1.5 — and this half binds it through
+ * ./scope.ts, probing rc.1's `configForms` first and 0.1.5's `settingsScope`
+ * second), so neither needs a new RPC or any edit to core packages;
  * composing this plugin out of cordis.yml removes every surface it adds.
  *
  * Why this exists: the official auto-compaction fires at `agent/pre-step`
@@ -31,10 +40,16 @@ export { resolveConfig } from './config.ts';
 export type { ContextGuardKey } from './locales.ts';
 export { guardReading } from './guard.ts';
 export type { GuardInput, GuardLevel, GuardReading } from './guard.ts';
-export type { CompactGuardButtonProps, ContextGuardInjected, ContextGuardSettingsCardInjected, ContextGuardSettingsCardProps, } from './slots.ts';
+export type { GuardScope, GuardScopeSnapshot } from './scope.ts';
+export type { CompactGuardButtonProps, ContextGuardBundleConfigProps, ContextGuardInjected, ContextGuardSettingsCardInjected, ContextGuardSettingsCardProps, } from './slots.ts';
 /** Dictionary namespace owned by this plugin. */
 export { NS };
-/** Required services: the slot ledger, the command Remote, the settings scope, and the copy. */
+/**
+ * Required services: the slot ledger, the command Remote, and the copy. The
+ * settings scope is deliberately NOT injected — rc.1 and 0.1.5 name different
+ * services (`configForms` vs `settingsScope`), and a composition without
+ * either must not pend the bundle (see ./scope.ts).
+ */
 export declare const inject: string[];
 /**
  * Client plugin body: register the composer-tool-row compact button and the

package/lib/types/client/index.js

@@ -1,14 +1,26 @@
 import { CONTEXT_GUARD_NS } from '../namespace.js';
 import { resolveConfig } from './config.js';
 import { en, NS, zh } from './locales.js';
+import { bindGuardScope, GuardScopeChannel } from './scope.js';
 import { CompactGuardButton } from './CompactGuardButton.js';
-import { ContextGuardSettingsCard } from './SettingsCard.js';
+import { ContextGuardBundleConfig, ContextGuardSettingsCard } from './SettingsCard.js';
 export { resolveConfig } from './config.js';
 export { guardReading } from './guard.js';
 /** Dictionary namespace owned by this plugin. */
 export { NS };
-/** Required services: the slot ledger, the command Remote, the settings scope, and the copy. */
-export const inject = ['slots', 'remote', 'remote.commands', 'locale', 'settingsScope'];
+/**
+ * This bundle's package name — the key the Plugins page dispatches
+ * `plugins.bundle.config` entries on (identity triangle: cordis.patch.yml,
+ * tsdown.config.ts, invariant.ts).
+ */
+const PACKAGE_NAME = '@khorsheed/dsh-context-guard';
+/**
+ * Required services: the slot ledger, the command Remote, and the copy. The
+ * settings scope is deliberately NOT injected — rc.1 and 0.1.5 name different
+ * services (`configForms` vs `settingsScope`), and a composition without
+ * either must not pend the bundle (see ./scope.ts).
+ */
+export const inject = ['slots', 'remote', 'remote.commands', 'locale'];
 /**
  * Client plugin body: register the composer-tool-row compact button and the
  * settings card over the shared `context-guard` section.
@@ -19,9 +31,11 @@ export function apply(ctx, config) {
     const fallback = resolveConfig(config);
     ctx.effect(() => ctx.locale.register(NS, { zh, en }), 'context-guard: dictionaries');
     // One shared live section: the settings card writes it, the button reads
-    // it. While the settings surface is absent, the button falls back to the
-    // composition-time values above.
-    const scope = ctx.settingsScope.bind({ namespace: CONTEXT_GUARD_NS });
+    // it. The channel binds whichever settings face the host line serves and
+    // publishes `unavailable` until then — the button falls back to the
+    // composition-time values above, the card renders nothing.
+    const scope = new GuardScopeChannel();
+    bindGuardScope(ctx, scope);
     // The slot is declared by ui-conversation, whose apply order relative to
     // this plugin is unconstrained: register through slots.inject so the entry
     // waits for the declaration instead of crashing the loader at boot.
@@ -46,10 +60,38 @@ export function apply(ctx, config) {
             hooks: { config: scope },
         }),
     }, CompactGuardButton));
-    // The plugin configuration tab keys its cards on the settings namespace, so
-    // the compact-timing card registers under CONTEXT_GUARD_NS and renders
-    // wherever the tab dispatches that key.
-    ctx.slots.inject('settings.plugin.item', () => ctx.slots.register({
+    // The settings surface follows the host line AND the install shape — three
+    // tracks, all riding slots.inject so each fires only where its declaration
+    // exists. Standalone install: the package's own Plugins-page detail view
+    // (`plugins.bundle.config`, keyed by package name). Installed as a
+    // conversation-toolbox member: the member is no longer the profile's
+    // direct dependency, so only the bundle gets a detail view — the card rides
+    // the row-level slot (`plugins.row.config`, keyed `<bundle package>#<row
+    // id>` with the row id the bundle's patch declares) and the bundle's page
+    // gains a configure entry opening it. 0.1.5: the legacy
+    // configurable-plugins tab card (`settings.plugin.item`, keyed by the
+    // settings namespace) through a string-keyed duck narrow of the same
+    // service (the slot name is gone from the alpha.2 SlotMap).
+    ctx.slots.inject('plugins.bundle.config', () => ctx.slots.register({
+        name: 'plugins.bundle.config',
+        key: PACKAGE_NAME,
+        locale: NS,
+        inject: () => ({
+            scope,
+            hooks: { config: scope },
+        }),
+    }, ContextGuardBundleConfig));
+    ctx.slots.inject('plugins.row.config', () => ctx.slots.register({
+        name: 'plugins.row.config',
+        key: '@khorsheed/dsh-bundle-conversation-toolbox#context-guard',
+        locale: NS,
+        inject: () => ({
+            scope,
+            hooks: { config: scope },
+        }),
+    }, ContextGuardBundleConfig));
+    const legacy = ctx.slots;
+    legacy.inject('settings.plugin.item', () => legacy.register({
         name: 'settings.plugin.item',
         key: CONTEXT_GUARD_NS,
         locale: NS,

package/lib/types/client/scope.d.ts

@@ -0,0 +1,62 @@
+/**
+ * The two host lines' per-namespace settings scope behind one observable.
+ *
+ * 0.1.5 binds `ctx.settingsScope`; rc.1 replaced that service with
+ * `ctx.configForms` — the two carry the SAME snapshot shape and the same
+ * field writes (only the resolutions gained an acceptance boolean, which the
+ * card's then/catch usage never reads), so one structural face covers both.
+ * Neither service is declared in the plugin's inject list: a composition
+ * without ui-settings must not pend the bundle, and the providers can mount
+ * after this plugin, so the channel publishes `unavailable` until either
+ * line's deferred probe arms it.
+ *
+ * @module @khorsheed/dsh-context-guard/client/scope
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { ContextGuardConfig } from './config.ts';
+/** Snapshot shape shared by 0.1.5's `SettingsScopeSnapshot` and rc.1's `ConfigFormSnapshot`. */
+export interface GuardScopeSnapshot {
+    readonly status: 'loading' | 'ready' | 'unavailable';
+    readonly value: ContextGuardConfig | undefined;
+    /** Composition layer the value resolves over; a cleared field reverts to it. */
+    readonly base: unknown;
+    /** Raw user layer as stored; a field's PRESENCE here marks it overridden. */
+    readonly user: unknown;
+    /** Namespace revision fencing the next write. */
+    readonly revision: number | undefined;
+    readonly writable: boolean;
+}
+/** The reads and field writes both lines' scopes share. */
+export interface GuardScope {
+    getSnapshot(): GuardScopeSnapshot;
+    subscribe(listener: () => void): () => void;
+    set(field: string, value: unknown): Promise<unknown>;
+    unset(field: string): Promise<unknown>;
+}
+/**
+ * Observable mirror of the bound scope. The slot entries' `hooks.config` seat
+ * binds to this at registration time — before (and whether or not) a settings
+ * provider appears — and arming swaps the source in and republishes.
+ */
+export declare class GuardScopeChannel {
+    private scope;
+    private readonly listeners;
+    readonly getSnapshot: () => GuardScopeSnapshot;
+    readonly subscribe: (listener: () => void) => (() => void);
+    readonly set: (field: string, value: unknown) => Promise<unknown>;
+    readonly unset: (field: string) => Promise<unknown>;
+    /** Bind the line-served scope; the first arm wins (the two lines never coexist). */
+    arm(scope: GuardScope): void;
+    private emit;
+}
+/**
+ * Arm the channel from whichever settings face the host line serves: rc.1's
+ * `configForms.get(entryId)` — the entry id IS the settings namespace, both
+ * being the row id — first, 0.1.5's `settingsScope.bind({ namespace })`
+ * second. Both probes ride deferred injects so a later-mounting provider
+ * still lands; a composition with neither leaves the channel unavailable.
+ * @param ctx - the client plugin context.
+ * @param channel - the observable the slot entries read.
+ */
+export declare function bindGuardScope(ctx: Context, channel: GuardScopeChannel): void;
+//# sourceMappingURL=scope.d.ts.map

package/lib/types/client/scope.js

@@ -0,0 +1,59 @@
+import { CONTEXT_GUARD_NS } from '../namespace.js';
+/** Published while no settings provider serves the section (stable identity). */
+const UNAVAILABLE = {
+    status: 'unavailable',
+    value: undefined,
+    base: undefined,
+    user: undefined,
+    revision: undefined,
+    writable: false,
+};
+/**
+ * Observable mirror of the bound scope. The slot entries' `hooks.config` seat
+ * binds to this at registration time — before (and whether or not) a settings
+ * provider appears — and arming swaps the source in and republishes.
+ */
+export class GuardScopeChannel {
+    scope;
+    listeners = new Set();
+    getSnapshot = () => this.scope?.getSnapshot() ?? UNAVAILABLE;
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => { this.listeners.delete(listener); };
+    };
+    set = (field, value) => this.scope?.set(field, value) ?? Promise.resolve(false);
+    unset = (field) => this.scope?.unset(field) ?? Promise.resolve(false);
+    /** Bind the line-served scope; the first arm wins (the two lines never coexist). */
+    arm(scope) {
+        if (this.scope !== undefined)
+            return;
+        this.scope = scope;
+        scope.subscribe(() => { this.emit(); });
+        this.emit();
+    }
+    emit() {
+        for (const listener of this.listeners)
+            listener();
+    }
+}
+/**
+ * Arm the channel from whichever settings face the host line serves: rc.1's
+ * `configForms.get(entryId)` — the entry id IS the settings namespace, both
+ * being the row id — first, 0.1.5's `settingsScope.bind({ namespace })`
+ * second. Both probes ride deferred injects so a later-mounting provider
+ * still lands; a composition with neither leaves the channel unavailable.
+ * @param ctx - the client plugin context.
+ * @param channel - the observable the slot entries read.
+ */
+export function bindGuardScope(ctx, channel) {
+    ctx.inject(['configForms'], (formsCtx) => {
+        const forms = formsCtx.get('configForms');
+        if (typeof forms?.get === 'function')
+            channel.arm(forms.get(CONTEXT_GUARD_NS));
+    });
+    ctx.inject(['settingsScope'], (legacyCtx) => {
+        const legacy = legacyCtx.get('settingsScope');
+        if (typeof legacy?.bind === 'function')
+            channel.arm(legacy.bind({ namespace: CONTEXT_GUARD_NS }));
+    });
+}

package/lib/types/client/slots.d.ts

@@ -1,12 +1,16 @@
 /**
  * Slot-facing types of the context-guard client half: the injected faces of
- * the composer-tool-row compact button and the settings card, both carrying
- * the shared `context-guard` settings scope as a hooks source so the button
- * and the card react to the same live section.
+ * the composer-tool-row compact button and the settings surfaces, both
+ * carrying the shared `context-guard` settings scope as a hooks source so the
+ * button and the card react to the same live section. The settings surface
+ * has one face per host line: the alpha.2 Plugins page renders the bundle's
+ * configuration (`plugins.bundle.config`, keyed by package name, owner prop
+ * `view`); the 0.1.5 configurable-plugins tab renders the card
+ * (`settings.plugin.item`, keyed by the settings namespace, owner props
+ * intentionally empty — the structural type below is exact).
  */
 import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
-import type { SettingsScope } from '@deepseek-ai/dsh-client-ui-settings/client';
-import type { ContextGuardConfig } from './config.ts';
+import type { GuardScope } from './scope.ts';
 /** Injected action face of the composer-tool-row entry. */
 export interface ContextGuardInjected {
     /** Resolved context-occupancy fraction at which the guard turns on; the boot-time fallback. */
@@ -20,20 +24,27 @@ export interface ContextGuardInjected {
     compactNow: () => Promise<string | null>;
     hooks: {
         /** The shared `context-guard` settings section; the button binds `useConfig` to it. */
-        config: SettingsScope<ContextGuardConfig>;
+        config: GuardScope;
     };
 }
 /** Full props of the composer-tool-row compact entry. */
 export type CompactGuardButtonProps = PropsRuntime<'conversation.input.right'> & InjectFace<ContextGuardInjected> & PropsLocale<'context-guard'>;
-/** Injected face of the settings card: the same shared section, read and written here. */
+/** Injected face of both settings surfaces: the same shared section, read and written here. */
 export interface ContextGuardSettingsCardInjected {
     /** The live section handle; the card stages edits and writes through it on save. */
-    scope: SettingsScope<ContextGuardConfig>;
+    scope: GuardScope;
     hooks: {
         /** The shared `context-guard` settings section; the card binds `useConfig` to it. */
-        config: SettingsScope<ContextGuardConfig>;
+        config: GuardScope;
     };
 }
-/** Full props of the settings.plugin.item card entry. */
-export type ContextGuardSettingsCardProps = PropsRuntime<'settings.plugin.item'> & InjectFace<ContextGuardSettingsCardInjected> & PropsLocale<'context-guard'>;
+/**
+ * Full props of the 0.1.5 settings.plugin.item card entry. The removed slot's
+ * owner share was intentionally empty, so the props are the injected face and
+ * the locale seat alone; the registration goes through a duck-typed narrow of
+ * the slots service (see client/index.ts).
+ */
+export type ContextGuardSettingsCardProps = InjectFace<ContextGuardSettingsCardInjected> & PropsLocale<'context-guard'>;
+/** Full props of the alpha.2 plugins.bundle.config entry (owner prop `view`). */
+export type ContextGuardBundleConfigProps = PropsRuntime<'plugins.bundle.config'> & InjectFace<ContextGuardSettingsCardInjected> & PropsLocale<'context-guard'>;
 //# sourceMappingURL=slots.d.ts.map