@boyingliu01/xp-gate 0.32.0 → 0.32.2

package/plugins/dsh/lib/delphi-settings.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Delphi seats supplied through DSH's own settings document.
+ *
+ * `.delphi-config.json` remains the portable, cross-platform source that the skill,
+ * the CI validator, and the other plugins share. This module adds a SECOND source —
+ * the `delphi` section of the plugin's Config, editable from the Plugins page — and
+ * the rules that keep the two from disagreeing in a way that costs money:
+ *
+ *  - the settings layer, when it has any seats, WINS (it is the more recent edit)
+ *  - it must still satisfy every Delphi invariant (`validateSeats`) before a single
+ *    request is made, because a form is a convenience and the host is the authority
+ *  - an absent settings layer resolves to `undefined`, so an existing JSON user is
+ *    never silently migrated to an empty panel
+ *
+ * @test REQ-DSH-017 Delphi seats are configurable from the DSH settings document
+ * @intent 把 DSH settings 里的 delphi 段解析成与 JSON 同构的席位，并在这条新路径上
+ *         重新执行三席/三模型互异/非占位符等不变量，避免表单绕过校验。
+ * @covers AC-DSH-017-01 AC-DSH-017-02 AC-DSH-017-03
+ */
+import type { ExpertSeat } from "./delphi.js";
+/** One seat as the settings document stores it. */
+export interface DelphiSettingsSeat {
+    role: string;
+    model: string;
+    maxTokens?: number;
+}
+/** The `delphi` section of the plugin Config. */
+export interface DelphiSettingsLayer {
+    baseUrl?: string;
+    apiKey?: string;
+    seats?: DelphiSettingsSeat[];
+    thresholdPercent?: number;
+    maxRounds?: number;
+}
+/** What {@link seatsFromSettings} produces: seats plus the transport they need. */
+export interface SettingsReviewSetup {
+    readonly seats: readonly ExpertSeat[];
+    readonly baseUrl: string;
+    /** The still-unexpanded `api_key` expression; the caller resolves it. */
+    readonly apiKeyExpression: string;
+    readonly thresholdPercent: number;
+    readonly maxRounds: number;
+}
+/**
+ * Turn the settings layer into a review setup, or `undefined` when it holds no seats.
+ *
+ * Throws the same errors the JSON path throws, so a caller can report either source
+ * through one handler. `validateSeats` runs before any network call, which is what
+ * makes a misconfigured panel a configuration error rather than a provider failure.
+ */
+export declare function seatsFromSettings(layer: DelphiSettingsLayer | undefined): SettingsReviewSetup | undefined;
+//# sourceMappingURL=delphi-settings.d.ts.map

package/plugins/dsh/lib/delphi-settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delphi-settings.d.ts","sourceRoot":"","sources":["../src/delphi-settings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAI7C,mDAAmD;AACnD,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,iDAAiD;AACjD,MAAM,WAAW,mBAAmB;IAClC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,kBAAkB,EAAE,CAAA;IAC5B,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,mFAAmF;AACnF,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAA;IACrC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,yEAAyE;IACzE,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IACjC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AA6BD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,mBAAmB,GAAG,SAAS,GAAG,mBAAmB,GAAG,SAAS,CA0BzG"}

package/plugins/dsh/lib/delphi-settings.js

@@ -0,0 +1,76 @@
+/**
+ * Delphi seats supplied through DSH's own settings document.
+ *
+ * `.delphi-config.json` remains the portable, cross-platform source that the skill,
+ * the CI validator, and the other plugins share. This module adds a SECOND source —
+ * the `delphi` section of the plugin's Config, editable from the Plugins page — and
+ * the rules that keep the two from disagreeing in a way that costs money:
+ *
+ *  - the settings layer, when it has any seats, WINS (it is the more recent edit)
+ *  - it must still satisfy every Delphi invariant (`validateSeats`) before a single
+ *    request is made, because a form is a convenience and the host is the authority
+ *  - an absent settings layer resolves to `undefined`, so an existing JSON user is
+ *    never silently migrated to an empty panel
+ *
+ * @test REQ-DSH-017 Delphi seats are configurable from the DSH settings document
+ * @intent 把 DSH settings 里的 delphi 段解析成与 JSON 同构的席位，并在这条新路径上
+ *         重新执行三席/三模型互异/非占位符等不变量，避免表单绕过校验。
+ * @covers AC-DSH-017-01 AC-DSH-017-02 AC-DSH-017-03
+ */
+import { validateSeats } from "./delphi.js";
+import { DelphiSetupError } from "./delphi-config.js";
+/** Delphi's documented defaults, applied when the settings omit a consensus value. */
+const DEFAULT_THRESHOLD_PERCENT = 90;
+const DEFAULT_MAX_ROUNDS = 5;
+/**
+ * Is the settings layer actually configured?
+ *
+ * Judged by seats alone: a half-filled form (a gateway typed but no seats yet) must
+ * not pre-empt the JSON file, or opening the page would quietly disable every
+ * existing `.delphi-config.json` review.
+ */
+function isConfigured(layer) {
+    return Array.isArray(layer?.seats) && layer.seats.length > 0;
+}
+/** Reject a layer that names no gateway, rather than dialling a guess. */
+function requireBaseUrl(layer) {
+    const baseUrl = (layer.baseUrl ?? "").trim();
+    if (baseUrl === "") {
+        throw new DelphiSetupError("The Delphi settings have seats but no base_url. Set the gateway URL, " +
+            "or clear the seats to fall back to .delphi-config.json.");
+    }
+    return baseUrl;
+}
+/**
+ * Turn the settings layer into a review setup, or `undefined` when it holds no seats.
+ *
+ * Throws the same errors the JSON path throws, so a caller can report either source
+ * through one handler. `validateSeats` runs before any network call, which is what
+ * makes a misconfigured panel a configuration error rather than a provider failure.
+ */
+export function seatsFromSettings(layer) {
+    if (!isConfigured(layer))
+        return undefined;
+    // Narrowed by isConfigured; non-null assertions are avoided to keep strict TS honest.
+    const configured = layer;
+    const rawSeats = configured.seats ?? [];
+    const seats = rawSeats.map((seat, index) => ({
+        id: seat.role || `Expert ${String.fromCharCode(65 + index)}`,
+        role: seat.role || `expert${index}`,
+        // Trim: a model id pasted from a catalog picker can carry padding, and
+        // `" model-a"` is not the model that was intended.
+        model: (seat.model ?? "").trim(),
+        maxTokens: seat.maxTokens,
+    }));
+    // The invariants are the reason this module exists; they run before the
+    // transport is even built.
+    validateSeats(seats);
+    return {
+        seats,
+        baseUrl: requireBaseUrl(configured),
+        apiKeyExpression: configured.apiKey ?? "",
+        thresholdPercent: configured.thresholdPercent ?? DEFAULT_THRESHOLD_PERCENT,
+        maxRounds: configured.maxRounds ?? DEFAULT_MAX_ROUNDS,
+    };
+}
+//# sourceMappingURL=delphi-settings.js.map

package/plugins/dsh/lib/hooks.d.ts

@@ -23,8 +23,21 @@ export interface GuardDenial {
     readonly kind: "deny";
     readonly reason: string;
 }
-/** Does this tool modify files? */
+/**
+ * Can this tool modify the workspace? Anything not proven read-only can.
+ *
+ * Used by the save-time principles check, which must fire only for the tools that
+ * actually write a source file — `bash` is excluded here even though the guard
+ * gates it, because the check needs a `file_path` argument to inspect.
+ */
 export declare function isEditTool(name: string): boolean;
+/**
+ * Must this tool be gated by the sprint review guard?
+ *
+ * The inverse of {@link READ_ONLY_TOOLS}: an unrecognised tool is treated as
+ * capable of writing, which is what closes the `bash` hole.
+ */
+export declare function mayModifyFiles(name: string): boolean;
 /**
  * Should a save-time check run for this path?
  *

package/plugins/dsh/lib/hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAYH,kFAAkF;AAClF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAsBD,mCAAmC;AACnC,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAKrD;AAgBD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CA8B3F"}
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAoCH,kFAAkF;AAClF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAsBD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAKrD;AAgBD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CA8B3F"}

package/plugins/dsh/lib/hooks.js

@@ -20,8 +20,32 @@
  */
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-/** Tools that modify files. Read-only tools are never gated. */
-const EDIT_TOOLS = new Set(["write", "edit", "str_replace_editor"]);
+/**
+ * Tools that provably cannot modify a file. Everything else is gated.
+ *
+ * This is an ALLOWLIST on purpose. The guard used to name the write tools
+ * instead (`write`, `edit`, `str_replace_editor`), which let `bash` through —
+ * one shell command writes a file, so the guard was bypassable by the very tool
+ * a model reaches for first. A write-blacklist loses again on every new
+ * file-touching tool; a read-only allowlist loses only by being too strict,
+ * which surfaces as an over-eager denial rather than a silent hole.
+ */
+const READ_ONLY_TOOLS = new Set([
+    "read",
+    "read_image",
+    "grep",
+    "glob",
+    "todo_write",
+    "ask_user_question",
+    "list_agents",
+    "present",
+    // XP-Gate's report tools only read: `xp-gate check/principles/arch` report to
+    // stdout, and the one file they ever write is a temp file list under the OS
+    // temp directory (gate-runner's --all path), never the workspace.
+    "gate-check",
+    "gate-principles",
+    "gate-arch",
+]);
 /** Where Sprint Flow records the review verdict. */
 const SPRINT_STATE_DIR = ".sprint-state";
 const VERDICT_FILE = "delphi-reviewed.json";
@@ -44,9 +68,24 @@ const CHECKABLE_EXTENSIONS = new Set([
     ".sh",
     ".ps1",
 ]);
-/** Does this tool modify files? */
+/**
+ * Can this tool modify the workspace? Anything not proven read-only can.
+ *
+ * Used by the save-time principles check, which must fire only for the tools that
+ * actually write a source file — `bash` is excluded here even though the guard
+ * gates it, because the check needs a `file_path` argument to inspect.
+ */
 export function isEditTool(name) {
-    return EDIT_TOOLS.has(name);
+    return name === "write" || name === "edit" || name === "str_replace_editor";
+}
+/**
+ * Must this tool be gated by the sprint review guard?
+ *
+ * The inverse of {@link READ_ONLY_TOOLS}: an unrecognised tool is treated as
+ * capable of writing, which is what closes the `bash` hole.
+ */
+export function mayModifyFiles(name) {
+    return !READ_ONLY_TOOLS.has(name);
 }
 /**
  * Should a save-time check run for this path?
@@ -82,7 +121,7 @@ function readVerdict(root) {
  * Returns undefined to mean "allow" so the caller can `if (denial) return denial`.
  */
 export function delphiGuardDecision(root, toolName) {
-    if (!isEditTool(toolName))
+    if (!mayModifyFiles(toolName))
         return undefined;
     if (!existsSync(join(root, SPRINT_STATE_DIR)))
         return undefined;

package/plugins/dsh/lib/index.d.ts

@@ -8,13 +8,76 @@ export declare const inject: string[];
  * Exported as a schema, not just a type: DSH validates against it and surfaces the
  * keys in the profile schema, so a user can discover and set them. A bare interface
  * is invisible to the harness.
+ *
+ * The `delphi` block is `.volatile()`: the settings page edits it live, and DSH
+ * refuses to write a path that is not beneath a volatile node. The two hook
+ * switches stay ordinary fields — they are read at mount and remounting a hook is
+ * what "off" is supposed to require.
  */
 export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     principlesCheck: z<"auto" | "off", "auto" | "off", "defined">;
     delphiGuard: z<"auto" | "off", "auto" | "off", "defined">;
+    delphi: z<NoInfer<Schemastery.ObjectS<NoInfer<{
+        baseUrl: z<string, string, "defined">;
+        apiKey: z<string, string, "defined">;
+        seats: z<({
+            role?: string | null | undefined;
+            model?: string | null | undefined;
+            maxTokens?: number | null | undefined;
+        } & import("@deepseek-ai/cosmokit").Dict)[], Schemastery.ObjectT<NoInfer<{
+            role: z<string, string, "defined">;
+            model: z<string, string, "defined">;
+            maxTokens: z<number, number, "plain">;
+        }>>[], "defined">;
+        thresholdPercent: z<number, number, "plain">;
+        maxRounds: z<number, number, "plain">;
+    }>>>, NoInfer<Schemastery.ObjectT<NoInfer<{
+        baseUrl: z<string, string, "defined">;
+        apiKey: z<string, string, "defined">;
+        seats: z<({
+            role?: string | null | undefined;
+            model?: string | null | undefined;
+            maxTokens?: number | null | undefined;
+        } & import("@deepseek-ai/cosmokit").Dict)[], Schemastery.ObjectT<NoInfer<{
+            role: z<string, string, "defined">;
+            model: z<string, string, "defined">;
+            maxTokens: z<number, number, "plain">;
+        }>>[], "defined">;
+        thresholdPercent: z<number, number, "plain">;
+        maxRounds: z<number, number, "plain">;
+    }>>>, "volatile">;
 }>>, Schemastery.ObjectT<NoInfer<{
     principlesCheck: z<"auto" | "off", "auto" | "off", "defined">;
     delphiGuard: z<"auto" | "off", "auto" | "off", "defined">;
+    delphi: z<NoInfer<Schemastery.ObjectS<NoInfer<{
+        baseUrl: z<string, string, "defined">;
+        apiKey: z<string, string, "defined">;
+        seats: z<({
+            role?: string | null | undefined;
+            model?: string | null | undefined;
+            maxTokens?: number | null | undefined;
+        } & import("@deepseek-ai/cosmokit").Dict)[], Schemastery.ObjectT<NoInfer<{
+            role: z<string, string, "defined">;
+            model: z<string, string, "defined">;
+            maxTokens: z<number, number, "plain">;
+        }>>[], "defined">;
+        thresholdPercent: z<number, number, "plain">;
+        maxRounds: z<number, number, "plain">;
+    }>>>, NoInfer<Schemastery.ObjectT<NoInfer<{
+        baseUrl: z<string, string, "defined">;
+        apiKey: z<string, string, "defined">;
+        seats: z<({
+            role?: string | null | undefined;
+            model?: string | null | undefined;
+            maxTokens?: number | null | undefined;
+        } & import("@deepseek-ai/cosmokit").Dict)[], Schemastery.ObjectT<NoInfer<{
+            role: z<string, string, "defined">;
+            model: z<string, string, "defined">;
+            maxTokens: z<number, number, "plain">;
+        }>>[], "defined">;
+        thresholdPercent: z<number, number, "plain">;
+        maxRounds: z<number, number, "plain">;
+    }>>>, "volatile">;
 }>>, "plain">;
 export declare function apply(ctx: Context, config?: unknown): void;
 //# sourceMappingURL=index.d.ts.map

package/plugins/dsh/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAOA,OAAO,CAAC,MAAM,0BAA0B,CAAA;AACxC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAgBlD,eAAO,MAAM,IAAI,iBAAiB,CAAA;AAGlC,eAAO,MAAM,MAAM,UAA+B,CAAA;AA0TlD;;;;;;GAMG;AACH,eAAO,MAAM,MAAM;;;;;;aAajB,CAAA;AAEF,wBAAgB,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,GAAE,OAAY,GAAG,IAAI,CA6B9D"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAOA,OAAO,CAAC,MAAM,0BAA0B,CAAA;AACxC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AA0BlD,eAAO,MAAM,IAAI,iBAAiB,CAAA;AAGlC,eAAO,MAAM,MAAM,UAA+B,CAAA;AAsZlD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA4BjB,CAAA;AAEF,wBAAgB,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,GAAE,OAAY,GAAG,IAAI,CA6B9D"}

package/plugins/dsh/lib/index.js

@@ -5,7 +5,9 @@ import { defineTool } from "@deepseek-ai/dsh-tools";
 import z from "@deepseek-ai/schemastery";
 import { GATE_WHITELIST, buildCommand, detectDialect, resolveTarget } from "./command.js";
 import { runXpGate } from "./gate-runner.js";
-import { DelphiSetupError, listCredentialReferences, loadDelphiConfig, toDelphiOptions } from "./delphi-config.js";
+import { DelphiSetupError, expandEnvDetailed, listCredentialReferences, loadDelphiConfig, toDelphiOptions, } from "./delphi-config.js";
+import { DelphiConfigError } from "./delphi.js";
+import { seatsFromSettings } from "./delphi-settings.js";
 import { formatOutcome, runReview } from "./delphi-run.js";
 import { buildEvidence } from "./evidence.js";
 import { readGitContext } from "./git-context.js";
@@ -166,40 +168,110 @@ async function writeWalkthroughEvidence(cwd, cfg, outcome) {
         return `\nEvidence: not written — ${error.message}`;
     }
 }
+/**
+ * Build the review options from whichever source is configured.
+ *
+ * The settings page wins when it holds seats: it is the more recent edit, and a
+ * user who just saved three models expects the next run to use them. When it holds
+ * none, `.delphi-config.json` applies exactly as before — which is what keeps every
+ * existing project working without opening the page.
+ *
+ * Both paths end in the same `validateSeats`, so neither can produce a panel the
+ * skill would reject.
+ */
+async function reviewOptions(request, resolveApiKey) {
+    const fromSettings = seatsFromSettings(request.settings);
+    if (fromSettings) {
+        // The seat list is already validated; only the key still has to be resolved,
+        // and only the credential store (not this process's environment) knows it.
+        const key = await resolveExpressionKey(fromSettings.apiKeyExpression, resolveApiKey);
+        return {
+            options: {
+                baseUrl: fromSettings.baseUrl,
+                apiKey: key,
+                seats: fromSettings.seats,
+                thresholdPercent: fromSettings.thresholdPercent,
+                maxRounds: request.maxRounds ?? fromSettings.maxRounds,
+            },
+            provider: "settings",
+            described: fromSettings.seats.map((s) => s.model).join(", "),
+        };
+    }
+    // Resolve credentials BEFORE loading the config: the loader is synchronous and
+    // throws as soon as a referenced variable has no value. Reading the reference
+    // names first turns "the DSH process never inherited WHALECLOUD_API_KEY" from a
+    // hard failure into a lookup in the credential store.
+    const apiKeyOverrides = {};
+    for (const name of listCredentialReferences(request.cwd)) {
+        const value = await resolveApiKey(name);
+        if (value !== undefined && value.length > 0)
+            apiKeyOverrides[name] = value;
+    }
+    const cfg = loadDelphiConfig(request.cwd, process.env, undefined, apiKeyOverrides);
+    const options = toDelphiOptions(cfg);
+    return {
+        options: { ...options, maxRounds: request.maxRounds ?? cfg.maxRounds },
+        provider: cfg.provider,
+        described: cfg.seats.map((s) => s.model).join(", "),
+        cfg,
+    };
+}
+/**
+ * Resolve a settings-supplied `api_key` expression to a usable token.
+ *
+ * Accepts the same two placeholder spellings the JSON loader accepts. A literal
+ * value is rejected rather than used: a bearer token typed into a settings field is
+ * a credential written to a profile file in plain text.
+ */
+async function resolveExpressionKey(expression, resolveApiKey) {
+    const placeholder = findPlaceholderName(expression);
+    if (placeholder === undefined) {
+        if (expression.trim() !== "") {
+            throw new DelphiSetupError("The Delphi settings hold a literal api key. Use a credential reference instead, " +
+                'e.g. "${WHALECLOUD_API_KEY}", so the token never lands in the profile file.');
+        }
+        throw new DelphiSetupError('The Delphi settings have no api key. Set it to "${YOUR_KEY_VAR}".');
+    }
+    const fromStore = await resolveApiKey(placeholder);
+    if (fromStore !== undefined && fromStore.length > 0)
+        return fromStore;
+    const fromEnv = expandEnvDetailed(expression, process.env);
+    if (fromEnv.value.trim() !== "")
+        return fromEnv.value;
+    throw new DelphiSetupError(`API key variable ${placeholder} has no value. Set it, or store it in DSH's credential store.`);
+}
+/** The first `${VAR}` / `{env:VAR}` name in a config value, or undefined. */
+function findPlaceholderName(value) {
+    const shell = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/.exec(value);
+    if (shell)
+        return shell[1];
+    const envStyle = /\{env:([A-Za-z_][A-Za-z0-9_]*)\}/.exec(value);
+    return envStyle ? envStyle[1] : undefined;
+}
 async function runDelphiReview(subject, request) {
-    const { addressed, maxRounds, cwd, resolveApiKey, signal, writeEvidence } = request;
+    const { addressed, cwd, resolveApiKey, signal, writeEvidence } = request;
     try {
-        // Resolve credentials BEFORE loading the config: the loader is synchronous and
-        // throws as soon as a referenced variable has no value. Reading the reference
-        // names first turns "the DSH process never inherited WHALECLOUD_API_KEY" from a
-        // hard failure into a lookup in the credential store.
-        const apiKeyOverrides = {};
-        for (const name of listCredentialReferences(cwd)) {
-            const value = await resolveApiKey(name);
-            if (value !== undefined && value.length > 0)
-                apiKeyOverrides[name] = value;
-        }
-        const cfg = loadDelphiConfig(cwd, process.env, undefined, apiKeyOverrides);
-        const options = toDelphiOptions(cfg);
-        const outcome = await runReview({ ...options, maxRounds: maxRounds ?? cfg.maxRounds }, subject, addressed, signal);
-        const seats = cfg.seats.map((s) => s.model).join(", ");
-        const suffix = writeEvidence
+        const { options, provider, described, cfg } = await reviewOptions(request, resolveApiKey);
+        const outcome = await runReview(options, subject, addressed, signal);
+        const suffix = writeEvidence && cfg !== undefined
             ? await writeWalkthroughEvidence(cwd, cfg, outcome)
             : "";
-        return `${formatOutcome(outcome)}\n\nProvider: ${cfg.provider}\nSeats: ${seats}${suffix}`;
+        return `${formatOutcome(outcome)}\n\nProvider: ${provider}\nSeats: ${described}${suffix}`;
     }
     catch (e) {
         // Config problems are the common failure; report them as guidance
         // rather than a stack trace.
         if (e instanceof DelphiSetupError)
             return `Delphi review not started: ${e.message}`;
+        if (e instanceof DelphiConfigError)
+            return `Delphi review not started: ${e.message}`;
         throw e;
     }
 }
-function delphiReviewTool(resolveApiKey) {
+function delphiReviewTool(resolveApiKey, settings) {
     return defineTool({
         name: "delphi-review",
-        description: "Run a Delphi cross-review of a subject (a diff, a design, a spec) using three DISTINCT models from an external OpenAI-compatible provider configured in .delphi-config.json. Round 1 is anonymous and concurrent; later rounds feed back the aggregate until the approval ratio reaches the configured threshold (default 90%) or the round cap (default 5). Use this whenever a change needs independent multi-model review rather than a single model's opinion.",
+        description: "Run a Delphi cross-review of a subject (a diff, a design, a spec) using three DISTINCT models from an external OpenAI-compatible provider. The seats come from the plugin's settings page (Plugins -> xp-gate -> Configure) when it holds any, otherwise from .delphi-config.json. Round 1 is anonymous and concurrent; later rounds feed back the aggregate until the approval ratio reaches the configured threshold (default 90%) or the round cap (default 5). Use this whenever a change needs independent multi-model review rather than a single model's opinion.",
         parameters: {
             subject: {
                 type: "string",
@@ -237,6 +309,7 @@ function delphiReviewTool(resolveApiKey) {
                 resolveApiKey,
                 signal: exec.signal,
                 writeEvidence: args.writeEvidence ?? false,
+                settings,
             });
         },
     });
@@ -285,12 +358,31 @@ function sprintTool(shell, dialect) {
         },
     });
 }
+/**
+ * One Delphi seat, as the settings page stores it.
+ *
+ * `model` is a free string rather than an enum: the catalog the page offers comes
+ * from the Host's configured providers, which this schema cannot enumerate, and a
+ * model id that is not in the catalog yet must still be accepted so an operator can
+ * pin a gateway alias. The invariants that matter are checked by
+ * `seatsFromSettings` on every run, not by the schema.
+ */
+const DelphiSeatSchema = z.object({
+    role: z.string().default(""),
+    model: z.string().default("").description("Model id sent to the gateway, e.g. g-glm-5.3-flash."),
+    maxTokens: z.number().min(0).description("Per-seat token budget; raise it for reasoning models."),
+});
 /**
  * Runtime schema for the keys above.
  *
  * Exported as a schema, not just a type: DSH validates against it and surfaces the
  * keys in the profile schema, so a user can discover and set them. A bare interface
  * is invisible to the harness.
+ *
+ * The `delphi` block is `.volatile()`: the settings page edits it live, and DSH
+ * refuses to write a path that is not beneath a volatile node. The two hook
+ * switches stay ordinary fields — they are read at mount and remounting a hook is
+ * what "off" is supposed to require.
  */
 export const Config = z.object({
     principlesCheck: z
@@ -301,6 +393,19 @@ export const Config = z.object({
         .union([z.const("auto"), z.const("off")])
         .default("auto")
         .description("Sprint write guard: auto = deny edits until delphi-review is APPROVED; off = do not register the hook."),
+    delphi: z
+        .object({
+        baseUrl: z.string().default("").description("OpenAI-compatible gateway, e.g. https://host/gpt-proxy."),
+        apiKey: z
+            .string()
+            .default("")
+            .description("Credential reference such as ${WHALECLOUD_API_KEY}; never a literal key."),
+        seats: z.array(DelphiSeatSchema).default([]).description("The three Delphi reviewers."),
+        thresholdPercent: z.number().min(0).max(100).description("Approval bar; 3 seats at 90% means 3/3."),
+        maxRounds: z.number().min(1).max(20).description("Round cap before the review reports NO CONSENSUS."),
+    })
+        .volatile()
+        .description("Delphi seats edited on the Plugins page. Leave seats empty to use .delphi-config.json."),
 });
 export function apply(ctx, config = {}) {
     const cfg = config;
@@ -321,7 +426,7 @@ export function apply(ctx, config = {}) {
     ctx.tools.register(gateCheckTool(shell, dialect));
     ctx.tools.register(gatePrinciplesTool(shell, dialect));
     ctx.tools.register(gateArchTool(shell, dialect));
-    ctx.tools.register(delphiReviewTool(resolveApiKey));
+    ctx.tools.register(delphiReviewTool(resolveApiKey, cfg.delphi));
     ctx.tools.register(sprintTool(shell, dialect));
     // Publishing the 12 bundled skills is what makes them visible to the model.
     // They ship in the tarball either way, but without a provider no discovery

package/plugins/dsh/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boyingliu01/dsh-plugin-xp-gate",
-  "version": "0.32.0",
+  "version": "0.32.2",
   "description": "XP-Gate deterministic quality gates + AI workflow skills as a DeepSeek Harness (DSH) native plugin: gate-check / gate-principles / gate-arch tools + 12 SKILL.md skills",
   "type": "module",
   "main": "./lib/index.js",
@@ -11,7 +11,10 @@
       "import": "./lib/index.js",
       "default": "./lib/index.js"
     },
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./client": {
+      "default": "./lib/client.js"
+    }
   },
   "repository": {
     "type": "git",
@@ -21,6 +24,13 @@
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-settings"
+      ],
+      "platform": "web"
     }
   },
   "publishConfig": {
@@ -34,7 +44,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "tsc -p tsconfig.build.json && node scripts/copy-client.cjs",
     "check": "tsc -p tsconfig.json",
     "test": "vitest run",
     "prepare-skills": "node scripts/prepack.cjs",

package/plugins/dsh/scripts/copy-client.cjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * copy-client.cjs — put the hand-authored browser bundle where the package ships it.
+ *
+ * `client/client.js` is written by hand in the DSH client-module format
+ * (`window.__ModuleLoader__.load`), so it must NOT pass through tsc: it is not a
+ * TypeScript module and it references a browser global. The build therefore
+ * compiles `src/` to `lib/` and this step adds `lib/client.js` alongside.
+ *
+ * Run by the `build` script, so `npm run build` and the release both produce the
+ * file the `dsh.client` declaration promises.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const PLUGIN_ROOT = path.resolve(__dirname, '..');
+const SRC = path.join(PLUGIN_ROOT, 'client', 'client.js');
+const OUT = path.join(PLUGIN_ROOT, 'lib', 'client.js');
+
+if (!fs.existsSync(SRC)) {
+  console.error(`[client] ERROR: browser bundle missing at ${SRC}`);
+  process.exit(1);
+}
+
+fs.mkdirSync(path.dirname(OUT), { recursive: true });
+fs.copyFileSync(SRC, OUT);
+
+const rel = (p) => path.relative(PLUGIN_ROOT, p).split(path.sep).join('/');
+console.log(`[client] ${rel(SRC)} -> ${rel(OUT)}`);

package/plugins/dsh/skills/delphi-review/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/DELPHI-REVIEW KNOWLEDGE BASE
 
-**Generated:** 2026-10-28
-**Commit:** 0f58c300
+**Generated:** 2026-10-30
+**Commit:** 78786c3f
 **Branch:** main
-**Version:** 0.32.0.0
+**Version:** 0.32.2.0
 
 ## OVERVIEW
 Delphi Consensus Review — multi-round anonymous expert review (≥90% threshold, exactly 3 experts with distinct executable model IDs). Supports design, requirements, and code-walkthrough modes.

package/plugins/dsh/skills/sprint-flow/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/SPRINT-FLOW KNOWLEDGE BASE
 
-**Generated:** 2026-10-28
-**Commit:** 0f58c300
+**Generated:** 2026-10-30
+**Commit:** 78786c3f
 **Branch:** main
-**Version:** 0.32.0.0
+**Version:** 0.32.2.0
 
 ## OVERVIEW
 **6-phase** development pipeline (v2.0 compact redesign, Issue #290): PREP → DESIGN → BUILD → VERIFY → SHIP → CLOSE. Phase 3/6 BUILD default build mode is **ralph-loop** (REQ-level iteration, 40-67% token savings vs parallel). HARD-GATE between DESIGN (2/6) and BUILD (3/6): design must pass Delphi review (≥90% consensus) before any coding.

package/plugins/dsh/skills/test-specification-alignment/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/TEST-SPECIFICATION-ALIGNMENT KNOWLEDGE BASE
 
-**Generated:** 2026-10-28
-**Commit:** 0f58c300
+**Generated:** 2026-10-30
+**Commit:** 78786c3f
 **Branch:** main
-**Version:** 0.32.0.0
+**Version:** 0.32.2.0
 
 ## OVERVIEW
 Test-Specification Alignment Engine — two-stage validation ensuring tests accurately reflect requirements and design specs.