@boyingliu01/xp-gate 0.19.3 → 0.20.1

package/plugins/dsh/src/delphi.ts

@@ -0,0 +1,247 @@
+/**
+ * Delphi cross-review over an external OpenAI-compatible provider.
+ *
+ * This is the codified form of the manual run that produced PR #456: three
+ * DISTINCT models, each asked the same question independently and anonymously,
+ * iterated until the approval ratio clears the consensus threshold.
+ *
+ * Why a plugin tool rather than a shell one-liner: the DSH tool plane is where
+ * a session actually lives, so the mechanism has to be callable from there.
+ * DSH's own `tool-subagent` cannot serve this purpose -- subagents inherit one
+ * host-configured model, so they cannot guarantee three distinct models, and
+ * Delphi's whole value rests on that distinctness.
+ *
+ * @test REQ-DSH-016
+ * @intent 用外部 provider 的多个不同模型做匿名交叉评审并判定共识，
+ *         把「多模型交叉评审」固化成 DSH 可调用的机制而非一次性脚本。
+ * @covers AC-DSH-016-01
+ */
+
+/** One expert seat. `model` is the id sent to the provider. */
+export interface ExpertSeat {
+  readonly id: string
+  readonly role: string
+  readonly model: string
+  /** Reasoning models burn hidden tokens, so seats need independent budgets. */
+  readonly maxTokens?: number
+}
+
+/** A single expert's parsed verdict for one round. */
+export interface ExpertVerdict {
+  readonly id: string
+  readonly role: string
+  readonly requestedModel: string
+  readonly resolvedModel: string | null
+  readonly verdict: "APPROVED" | "REQUEST_CHANGES" | "INVALID_NO_VERDICT" | "ERROR"
+  readonly confidence: number
+  /** Only well-formed verdicts may count toward consensus. */
+  readonly counted: boolean
+  readonly report: string
+  readonly error?: string
+}
+
+/** Aggregated outcome of one round. */
+export interface RoundResult {
+  readonly round: number
+  readonly verdicts: readonly ExpertVerdict[]
+  readonly validCount: number
+  readonly approvals: number
+  readonly consensusRatio: number
+  readonly reachedConsensus: boolean
+}
+
+export interface DelphiOptions {
+  /** OpenAI-compatible base URL, e.g. https://host/gpt-proxy */
+  readonly baseUrl: string
+  /** Bearer token. Callers read this from the environment; never hardcode it. */
+  readonly apiKey: string
+  readonly seats: readonly ExpertSeat[]
+  /** Percent, 0-100. Delphi default is 90. */
+  readonly thresholdPercent?: number
+  readonly maxRounds?: number
+  /** Per-request ceiling; the caller owns the overall timeout. */
+  readonly timeoutMs?: number
+  readonly fetchImpl?: typeof fetch
+}
+
+/** Delphi's defining invariant: exactly three seats and a 90% approval bar. */
+const REQUIRED_EXPERTS = 3
+const DEFAULT_THRESHOLD_PERCENT = 90
+
+const DEFAULT_MAX_TOKENS = 8000
+const DEFAULT_TIMEOUT_MS = 180_000
+
+/** Raised when the configured seats cannot satisfy the Delphi invariants. */
+export class DelphiConfigError extends Error {}
+
+/**
+ * Reject a seat configuration that cannot produce a valid Delphi review.
+ * Checked BEFORE any network call so a misconfiguration never looks like a
+ * provider failure.
+ */
+export function validateSeats(seats: readonly ExpertSeat[]): void {
+  if (seats.length !== REQUIRED_EXPERTS) {
+    throw new DelphiConfigError(
+      `Delphi requires exactly ${REQUIRED_EXPERTS} experts, got ${seats.length}.`,
+    )
+  }
+  for (const s of seats) {
+    if (!s.model || s.model.trim() === "") {
+      throw new DelphiConfigError(`Expert "${s.id}" has no model (a local fallback cannot count).`)
+    }
+    if (s.model.includes("${")) {
+      throw new DelphiConfigError(`Expert "${s.id}" model "${s.model}" looks like an unexpanded env var.`)
+    }
+  }
+  const distinct = new Set(seats.map((s) => s.model.trim()))
+  if (distinct.size !== REQUIRED_EXPERTS) {
+    throw new DelphiConfigError(
+      `All ${REQUIRED_EXPERTS} experts must use distinct models; got: ${[...distinct].join(", ")}.`,
+    )
+  }
+}
+
+/**
+ * Parse an expert report into a verdict.
+ *
+ * The verdict token usually sits on the line AFTER a "### VERDICT" heading, so
+ * a same-line `VERDICT: X` pattern misses every real report. A report with no
+ * recognisable verdict is INVALID, never a guess: inferring approval from prose
+ * would let the gate pass on an assumption.
+ */
+export function parseVerdict(text: string): {
+  verdict: ExpertVerdict["verdict"]
+  confidence: number
+} {
+  const section = /VERDICT[\s\S]{0,120}?\b(APPROVED|REQUEST_CHANGES|PASS_WITH_CAVEATS|BLOCKED)\b/i.exec(text)
+  if (!section) return { verdict: "INVALID_NO_VERDICT", confidence: 0 }
+
+  const raw = section[1].toUpperCase()
+  // PASS_WITH_CAVEATS / BLOCKED are not approvals under the 90% rule.
+  const verdict = raw === "APPROVED" ? "APPROVED" : "REQUEST_CHANGES"
+
+  const c = /CONFIDENCE[\s\S]{0,40}?(\d{1,2})/i.exec(text)
+  const confidence = c ? Math.min(10, Math.max(0, Number(c[1]))) : 0
+  return { verdict, confidence }
+}
+
+interface ChatResponse {
+  model?: string
+  choices?: Array<{ finish_reason?: string; message?: { content?: string } }>
+}
+
+/** One provider call. Throws on transport failure or empty content. */
+async function chatOnce(
+  opts: DelphiOptions,
+  seat: ExpertSeat,
+  system: string,
+  user: string,
+): Promise<{ content: string; resolvedModel: string | null; finishReason: string }> {
+  const doFetch = opts.fetchImpl ?? fetch
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+
+  try {
+    const res = await doFetch(`${opts.baseUrl.replace(/\/+$/, "")}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${opts.apiKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: seat.model,
+        messages: [
+          { role: "system", content: system },
+          { role: "user", content: user },
+        ],
+        max_tokens: seat.maxTokens ?? DEFAULT_MAX_TOKENS,
+        temperature: 0.2,
+      }),
+      signal: controller.signal,
+    })
+
+    if (!res.ok) {
+      const body = await res.text().catch(() => "")
+      throw new Error(`HTTP ${res.status}: ${body.slice(0, 200)}`)
+    }
+
+    const json = (await res.json()) as ChatResponse
+    const content = json.choices?.[0]?.message?.content ?? ""
+    const finishReason = json.choices?.[0]?.finish_reason ?? "unknown"
+
+    // Empty content is a real failure -- typically a reasoning model that spent
+    // its whole budget on hidden tokens. Never let it pass as an empty review.
+    if (content.trim() === "") {
+      throw new Error(
+        `empty content (finish_reason=${finishReason}, max_tokens=${seat.maxTokens ?? DEFAULT_MAX_TOKENS}); ` +
+          `raise max_tokens if this is a reasoning model`,
+      )
+    }
+
+    return { content, resolvedModel: json.model ?? null, finishReason }
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+/**
+ * Run ONE round. All seats are asked concurrently and never see each other's
+ * output, which is what makes the round anonymous.
+ */
+export async function runRound(
+  opts: DelphiOptions,
+  round: number,
+  system: string,
+  buildPrompt: (seat: ExpertSeat) => string,
+): Promise<RoundResult> {
+  const settled = await Promise.allSettled(
+    opts.seats.map(async (seat) => {
+      const r = await chatOnce(opts, seat, system, buildPrompt(seat))
+      return { seat, ...r }
+    }),
+  )
+
+  const verdicts: ExpertVerdict[] = settled.map((s, i) => {
+    const seat = opts.seats[i]
+    if (s.status !== "fulfilled") {
+      return {
+        id: seat.id,
+        role: seat.role,
+        requestedModel: seat.model,
+        resolvedModel: null,
+        verdict: "ERROR",
+        confidence: 0,
+        counted: false,
+        report: "",
+        error: s.reason instanceof Error ? s.reason.message : String(s.reason),
+      }
+    }
+    const { verdict, confidence } = parseVerdict(s.value.content)
+    return {
+      id: seat.id,
+      role: seat.role,
+      requestedModel: seat.model,
+      resolvedModel: s.value.resolvedModel,
+      verdict,
+      confidence,
+      counted: verdict !== "INVALID_NO_VERDICT",
+      report: s.value.content,
+    }
+  })
+
+  const counted = verdicts.filter((v) => v.counted)
+  const approvals = counted.filter((v) => v.verdict === "APPROVED").length
+  // Consensus is measured over VALID responses: a malformed report is not a
+  // dissent, but it cannot be counted as agreement either.
+  const ratio = counted.length === 0 ? 0 : approvals / counted.length
+  const threshold = opts.thresholdPercent ?? DEFAULT_THRESHOLD_PERCENT
+
+  return {
+    round,
+    verdicts,
+    validCount: counted.length,
+    approvals,
+    consensusRatio: ratio,
+    reachedConsensus: counted.length === REQUIRED_EXPERTS && ratio * 100 >= threshold,
+  }
+}

package/plugins/dsh/src/dialect.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect } from "vitest"
+import { detectDialect, shellQuote, shq } from "./dialect.js"
+
+/**
+ * @test REQ-DSH-010
+ * @intent 验证 shell 方言探测与转义：win32 必须选 powershell（DSH 在 win32 启用 pwsh
+ *         executor），其余平台选 posix，且两套转义都不能让引号/元字符逃逸出字符串
+ * @covers AC-DSH-010-01
+ */
+describe("detectDialect", () => {
+  it("selects powershell on win32 and posix elsewhere", () => {
+    expect(detectDialect("win32")).toBe("powershell")
+    expect(detectDialect("linux")).toBe("posix")
+    expect(detectDialect("darwin")).toBe("posix")
+  })
+
+  it("matches the platform DSH actually enables an executor for", () => {
+    // dsh-base enables pwsh-sandbox/tool-pwsh only on win32, and
+    // bash-sandbox/tool-bash everywhere else.
+    expect(detectDialect()).toBe(process.platform === "win32" ? "powershell" : "posix")
+  })
+})
+
+describe("shellQuote", () => {
+  it("uses the POSIX quote-close idiom", () => {
+    expect(shellQuote("a'b", "posix")).toBe("'a'\\''b'")
+    expect(shellQuote("abc", "posix")).toBe("'abc'")
+  })
+
+  it("doubles embedded quotes for PowerShell", () => {
+    expect(shellQuote("a'b", "powershell")).toBe("'a''b'")
+    expect(shellQuote("abc", "powershell")).toBe("'abc'")
+  })
+
+  it("neutralizes POSIX shell metacharacters literally", () => {
+    const payload = "$(touch /tmp/pwned); `id`"
+    expect(shellQuote(payload, "posix")).toBe("'$(touch /tmp/pwned); `id`'")
+  })
+
+  /**
+   * @test REQ-DSH-011
+   * @intent 验证 PowerShell 单引号内 $() 与反引号均为字面量，且内嵌引号被双写，
+   *         使命令注入无法闭合字符串逃逸
+   * @covers AC-DSH-011-01
+   */
+  it("neutralizes PowerShell metacharacters and prevents quote escape", () => {
+    const payload = "$(touch /tmp/pwned); `id`"
+    expect(shellQuote(payload, "powershell")).toBe("'$(touch /tmp/pwned); `id`'")
+    // A payload that tries to close the string must have its quote doubled so it
+    // stays inside a single literal argument.
+    expect(shellQuote("a'; Remove-Item x; '", "powershell")).toBe("'a''; Remove-Item x; '''")
+  })
+})
+
+describe("shq (deprecated POSIX wrapper)", () => {
+  it("delegates to shellQuote with the posix dialect", () => {
+    expect(shq("a'b")).toBe(shellQuote("a'b", "posix"))
+  })
+})

package/plugins/dsh/src/dialect.ts

@@ -0,0 +1,40 @@
+/**
+ * Shell dialect selection and quoting.
+ *
+ * DSH chooses its shell backend per platform: `dsh-base` disables
+ * `bash-sandbox`/`tool-bash` and enables `pwsh-sandbox`/`tool-pwsh` on win32.
+ * A command string written for the wrong dialect fails to parse, so callers
+ * must pick the dialect to match the executor rather than assume POSIX.
+ */
+
+export type ShellDialect = "posix" | "powershell"
+
+/** Quote one argument for the target dialect. */
+export function shellQuote(value: string, dialect: ShellDialect): string {
+  if (dialect === "posix") {
+    // POSIX single-quote escaping: `'` becomes `'\''`.
+    return `'${value.replace(/'/g, "'\\''")}'`
+  }
+  // PowerShell single-quoted strings escape an embedded quote by doubling it.
+  // Backticks and `$(…)` are literal inside single quotes, so no further
+  // escaping is needed to keep them inert.
+  return `'${value.replace(/'/g, "''")}'`
+}
+
+/**
+ * POSIX single-quote shell escaping: `'` becomes `'\''`.
+ * @deprecated Use {@link shellQuote} with an explicit dialect.
+ */
+export function shq(value: string): string {
+  return shellQuote(value, "posix")
+}
+
+/**
+ * Pick the dialect for the current platform.
+ *
+ * `process.platform` is the reliable signal available inside a tool body; it
+ * mirrors exactly where DSH enables each sandbox/executor pair.
+ */
+export function detectDialect(platform: NodeJS.Platform = process.platform): ShellDialect {
+  return platform === "win32" ? "powershell" : "posix"
+}

package/plugins/dsh/src/index.ts

@@ -1,7 +1,9 @@
 import { defineTool } from "@deepseek-ai/dsh-tools"
 import type { Context } from "@deepseek-ai/cordis"
-import { GATE_WHITELIST, buildCommand, resolveTarget } from "./command.js"
+import { GATE_WHITELIST, buildCommand, detectDialect, resolveTarget } from "./command.js"
 import { runXpGate } from "./gate-runner.js"
+import { DelphiSetupError, loadDelphiConfig, toDelphiOptions } from "./delphi-config.js"
+import { formatOutcome, runReview } from "./delphi-run.js"
 
 export const name = "tool-xp-gate"
 export const inject = ["tools", "shell"]
@@ -10,6 +12,9 @@ const DEFAULT_TIMEOUT_MS = 120_000
 
 export function apply(ctx: Context, _config: unknown = {}): void {
   const shell = ctx.shell
+  // DSH runs a POSIX shell off-Windows and PowerShell on Windows; generating the
+  // wrong dialect makes every tool fail to parse rather than degrade gracefully.
+  const dialect = detectDialect()
 
   ctx.tools.register(
     defineTool({
@@ -36,7 +41,7 @@ export function apply(ctx: Context, _config: unknown = {}): void {
       async execute(args, exec) {
         const cwd = exec.agent?.session?.header?.cwd ?? process.cwd()
         const target = resolveTarget(args.path, cwd)
-        const command = buildCommand({ subcommand: "check", target, gates: args.gates })
+        const command = buildCommand({ subcommand: "check", target, gates: args.gates, dialect })
         return runXpGate(shell, exec.signal, command, cwd, DEFAULT_TIMEOUT_MS)
       },
     }),
@@ -62,7 +67,7 @@ export function apply(ctx: Context, _config: unknown = {}): void {
       async execute(args, exec) {
         const cwd = exec.agent?.session?.header?.cwd ?? process.cwd()
         const target = resolveTarget(args.path, cwd)
-        const command = buildCommand({ subcommand: "principles", target })
+        const command = buildCommand({ subcommand: "principles", target, dialect })
         return runXpGate(shell, exec.signal, command, cwd, DEFAULT_TIMEOUT_MS)
       },
     }),
@@ -86,9 +91,70 @@ export function apply(ctx: Context, _config: unknown = {}): void {
       timeoutMs: DEFAULT_TIMEOUT_MS,
       async execute(args, exec) {
         const cwd = exec.agent?.session?.header?.cwd ?? process.cwd()
-        const command = buildCommand({ subcommand: "arch", config: args.config })
+        const command = buildCommand({ subcommand: "arch", config: args.config, dialect })
         return runXpGate(shell, exec.signal, command, cwd, DEFAULT_TIMEOUT_MS)
       },
     }),
   )
+
+  // Delphi multi-model cross-review.
+  //
+  // DSH's own subagents cannot do this: they inherit one host-configured model,
+  // so three "experts" would be three instances of the same model, and Delphi's
+  // value rests entirely on the reviewers being DIFFERENT models. This tool
+  // therefore calls an external OpenAI-compatible provider directly, with one
+  // distinct model per seat.
+  ctx.tools.register(
+    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.",
+      parameters: {
+        subject: {
+          type: "string",
+          required: true,
+          description:
+            "The material to review, inline. For a diff, pass the diff text (or a summarized form if very large).",
+        },
+        addressed: {
+          type: "string",
+          description:
+            "Optional description of what changed since a previous round, fed back to later rounds so reviewers can revise their position.",
+        },
+        maxRounds: {
+          type: "number",
+          description: "Override the configured round cap (Delphi default is 5).",
+        },
+        cwd: {
+          type: "string",
+          description: "Project root containing .delphi-config.json (defaults to the session cwd).",
+        },
+      },
+      output: {
+        schema: { type: "string" },
+        render: (_args, value) => [{ type: "text", text: value }],
+      },
+      // Multi-round reviews over large inputs are slow; the transport applies
+      // its own per-request timeout on top of this ceiling.
+      timeoutMs: 900_000,
+      async execute(args, exec) {
+        const cwd = args.cwd ?? exec.agent?.session?.header?.cwd ?? process.cwd()
+        try {
+          const cfg = loadDelphiConfig(cwd)
+          const outcome = await runReview(
+            { ...toDelphiOptions(cfg), maxRounds: args.maxRounds ?? cfg.maxRounds },
+            args.subject,
+            args.addressed ?? "",
+          )
+          const seats = cfg.seats.map((s) => s.model).join(", ")
+          return `${formatOutcome(outcome)}\n\nProvider: ${cfg.provider}\nSeats: ${seats}`
+        } 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}`
+          throw e
+        }
+      },
+    }),
+  )
 }

package/plugins/dsh/src/skills.test.ts

@@ -7,22 +7,22 @@ import { parse } from "yaml"
 /** Mirrors `SKILL_NAME` in @deepseek-ai/dsh-skill. */
 const SKILL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/
 
-const EXPECTED_SKILLS = [
-  "admin-template-guidelines",
-  "batch-grill-me",
-  "delphi-review",
-  "domain-modeling",
-  "grilling",
-  "grill-with-docs",
-  "improve-codebase-architecture",
-  "ralph-loop",
-  "sprint-flow",
-  "test-driven-development",
-  "test-specification-alignment",
-  "to-issues",
-]
+const PLUGIN_ROOT = resolve(fileURLToPath(new URL("..", import.meta.url)))
+const SKILLS_DIR = join(PLUGIN_ROOT, "skills")
+const REPO_SKILLS_DIR = resolve(PLUGIN_ROOT, "..", "..", "skills")
 
-const SKILLS_DIR = resolve(fileURLToPath(new URL("..", import.meta.url)), "skills")
+/**
+ * The expected set is the REPO's skill directories, discovered rather than
+ * hardcoded. A hardcoded list silently drifts: it previously named 12 skills and
+ * omitted clipboard-vision, while prepack shipped 12 of 13 (#448).
+ */
+function repoSkills(): string[] {
+  return readdirSync(REPO_SKILLS_DIR, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name)
+    .filter((name) => existsSync(join(REPO_SKILLS_DIR, name, "SKILL.md")))
+    .sort()
+}
 
 function readFrontmatter(file: string): Record<string, unknown> {
   const raw = readFileSync(file, "utf8")
@@ -32,22 +32,25 @@ function readFrontmatter(file: string): Record<string, unknown> {
 }
 
 describe("bundled skills", () => {
-  it("ships all 12 skills as directories", () => {
+  it("ships every repo skill as a directory", () => {
     expect(existsSync(SKILLS_DIR)).toBe(true)
     const dirs = readdirSync(SKILLS_DIR, { withFileTypes: true })
       .filter((d) => d.isDirectory())
       .map((d) => d.name)
       .sort()
-    expect(dirs).toEqual([...EXPECTED_SKILLS].sort())
+    expect(dirs).toEqual(repoSkills())
   })
 
   /**
    * @test REQ-DSH-006
-   * @intent 验证随包 12 个 skills 目录里各 SKILL.md 的 frontmatter 满足 DSH 契约（name kebab-case + description 非空）
+   * @intent 验证随包 skills 目录里各 SKILL.md 的 frontmatter 满足 DSH 契约
+   *         （name kebab-case + description 非空），且集合与仓库 skills/ 一致（#448）
    * @covers AC-DSH-006-01
    */
   it("every SKILL.md satisfies the DSH frontmatter contract", () => {
-    for (const name of EXPECTED_SKILLS) {
+    const names = repoSkills()
+    expect(names.length).toBeGreaterThan(0)
+    for (const name of names) {
       const fm = readFrontmatter(join(SKILLS_DIR, name, "SKILL.md"))
       expect(fm.name, `${name}: frontmatter.name`).toBeTypeOf("string")
       expect(SKILL_NAME.test(fm.name as string), `${name}: kebab-case name`).toBe(true)
@@ -55,4 +58,8 @@ describe("bundled skills", () => {
       expect((fm.description as string).trim().length, `${name}: non-empty description`).toBeGreaterThan(0)
     }
   })
+
+  it("bundles clipboard-vision, which the old hardcoded list omitted (#448)", () => {
+    expect(existsSync(join(SKILLS_DIR, "clipboard-vision", "SKILL.md"))).toBe(true)
+  })
 })

package/plugins/opencode/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boyingliu01/opencode-plugin",
-  "version": "0.19.3",
+  "version": "0.20.1",
   "type": "module",
   "main": "index.ts",
   "description": "XP-Gate quality gates + AI workflow skills + Sprint Flow TUI sidebar for OpenCode",

package/plugins/opencode/skills/clipboard-vision/__tests__/clipboard-vision-distribution.test.cjs

@@ -19,7 +19,6 @@ describe('clipboard-vision distribution', () => {
     'scripts/build-plugin.mjs',
     'scripts/build-plugin.sh',
     'scripts/test-plugins.mjs',
-    'scripts/test-plugins.sh',
     'src/npm-package/scripts/sync-package-content.js',
     'plugins/opencode/scripts/prepack.cjs',
     'src/npm-package/plugins/opencode/scripts/prepack.cjs',

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

@@ -1,9 +1,9 @@
 # SKILLS/DELPHI-REVIEW KNOWLEDGE BASE
 
-**Generated:** 2026-09-24
-**Commit:** 467174d
-**Branch:** main
-**Version:** 0.19.3.0
+**Generated:** 2026-10-08
+**Commit:** unknown
+**Branch:** unknown
+**Version:** 0.20.1.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.