@boyingliu01/xp-gate 0.31.3 → 0.32.0

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

@@ -0,0 +1,113 @@
+/**
+ * Delphi review orchestration: iterate rounds until consensus or the cap.
+ *
+ * @test REQ-DSH-016
+ * @intent 编排多轮交叉评审：首轮匿名独立评审，后续轮次反馈上一轮汇总，
+ *         直到达到共识阈值（默认 90%）或触及轮次上限（默认 5），
+ *         并把结果整理成可写成 .code-walkthrough-result.json 的证据。
+ * @covers AC-DSH-016-03
+ */
+import { TOOL_ABORTED } from "@deepseek-ai/dsh-tools";
+import { HarnessError } from "@deepseek-ai/dsh-llm";
+import { runRound } from "./delphi.js";
+/**
+ * Raise TOOL_ABORTED once the caller's signal has fired.
+ *
+ * Deliverance matches the gate tools exactly, so a cancelled review reads as a
+ * cancellation in the UI rather than as a provider outage.
+ */
+function assertNotAborted(signal) {
+    if (!signal?.aborted)
+        return;
+    const error = new HarnessError("tool call aborted", TOOL_ABORTED);
+    error.name = "AbortError";
+    throw error;
+}
+/** Mirrors delphi.ts; declared here so orchestrators need not import internals. */
+const DEFAULT_THRESHOLD_PERCENT = 90;
+const DEFAULT_MAX_ROUNDS = 5;
+/** Anonymous first round: each seat answers the same question with no peers. */
+function roundOnePrompt(seat, subject) {
+    return (`You are the ${seat.role.toUpperCase()} expert. Review the material below INDEPENDENTLY. ` +
+        `Do not assume other reviewers exist or agree with you.\n\n${subject}\n\n` +
+        `Respond with <=300 words under the headings: "### Findings" (a markdown table of ` +
+        `ID | Severity | Description | Location | Fix, or a single NONE row), then "### VERDICT" ` +
+        `followed by exactly APPROVED or REQUEST_CHANGES, then "### CONFIDENCE" followed by an ` +
+        `integer 1-10. Approve only if you would personally ship this.`);
+}
+/**
+ * Later rounds: feed back the aggregate so seats can revise their position.
+ * Individual reports stay anonymous -- only the tally and the addressed items
+ * are shared, which is what keeps the method honest.
+ */
+function laterRoundPrompt(seat, subject, previous, addressed) {
+    const tally = previous.verdicts
+        .map((v) => `- ${v.role}: ${v.verdict}`)
+        .join("\n");
+    return (`You are the ${seat.role.toUpperCase()} expert. This is ROUND ${previous.round + 1} of a ` +
+        `Delphi consensus review. Individual peer reports are anonymous; only this aggregate is shared:\n\n` +
+        `${tally}\nApprovals: ${previous.approvals}/${previous.validCount} ` +
+        `(threshold ${DEFAULT_THRESHOLD_PERCENT}%).\n\n` +
+        `${addressed ? `What changed since the last round:\n${addressed}\n\n` : ""}` +
+        `Re-examine the material and revise or hold your position.\n\n${subject}\n\n` +
+        `Respond with <=300 words: "### Round assessment" (2-3 sentences), "### Remaining blocking ` +
+        `issues" (table, or a single NONE row), "### VERDICT" followed by exactly APPROVED or ` +
+        `REQUEST_CHANGES, then "### CONFIDENCE" and an integer 1-10.`);
+}
+/**
+ * Run a full review. Round 1 is anonymous; each later round sees the aggregate
+ * plus whatever the caller says was addressed, then re-votes.
+ */
+export async function runReview(opts, subject, addressed = "", signal) {
+    const threshold = opts.thresholdPercent ?? DEFAULT_THRESHOLD_PERCENT;
+    const maxRounds = opts.maxRounds ?? DEFAULT_MAX_ROUNDS;
+    const rounds = [];
+    // A round swallows per-seat failures into ERROR verdicts, so cancellation has to
+    // be checked around them: otherwise an abort would surface as three ERROR seats and
+    // the review would grind on through every remaining round.
+    const effective = { ...opts, signal };
+    assertNotAborted(signal);
+    for (let n = 1; n <= maxRounds; n++) {
+        const previous = rounds[rounds.length - 1];
+        const result = previous
+            ? await runRound(effective, n, "You are a rigorous senior code reviewer.", (seat) => laterRoundPrompt(seat, subject, previous, addressed))
+            : await runRound(effective, 1, "You are a rigorous senior code reviewer.", (seat) => roundOnePrompt(seat, subject));
+        assertNotAborted(signal);
+        rounds.push(result);
+        // Threshold is a percentage of the whole panel, so a round with a malformed
+        // report cannot reach consensus even if every valid seat approved.
+        if (result.approvals / opts.seats.length * 100 >= threshold) {
+            return {
+                rounds,
+                consensus: true,
+                finalRatio: result.approvals / opts.seats.length,
+                totalRounds: n,
+            };
+        }
+    }
+    const last = rounds[rounds.length - 1];
+    return {
+        rounds,
+        consensus: false,
+        finalRatio: last ? last.approvals / opts.seats.length : 0,
+        totalRounds: rounds.length,
+    };
+}
+/** Human-readable transcript for the tool result. */
+export function formatOutcome(outcome) {
+    const lines = [];
+    for (const r of outcome.rounds) {
+        lines.push(`## Round ${r.round} — approvals ${r.approvals}/${r.validCount} valid`);
+        for (const v of r.verdicts) {
+            const model = v.resolvedModel ? `${v.requestedModel} -> ${v.resolvedModel}` : v.requestedModel;
+            const note = v.error ? ` (${v.error})` : "";
+            lines.push(`- [${v.role}] ${v.id} (${model}): ${v.verdict} confidence=${v.confidence}${note}`);
+        }
+        lines.push("");
+    }
+    lines.push(outcome.consensus
+        ? `CONSENSUS REACHED: ${(outcome.finalRatio * 100).toFixed(0)}% after ${outcome.totalRounds} round(s).`
+        : `NO CONSENSUS: ${(outcome.finalRatio * 100).toFixed(0)}% after ${outcome.totalRounds} round(s) (cap reached).`);
+    return lines.join("\n");
+}
+//# sourceMappingURL=delphi-run.js.map

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

@@ -0,0 +1,94 @@
+/**
+ * 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;
+    /**
+     * Caller cancellation. Aborting it stops the in-flight request immediately and
+     * raises TOOL_ABORTED, matching the three gate tools. Without this a cancelled
+     * review kept spending money on requests the user had already abandoned.
+     */
+    readonly signal?: AbortSignal;
+    readonly fetchImpl?: typeof fetch;
+}
+/** Raised when the configured seats cannot satisfy the Delphi invariants. */
+export declare 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 declare function validateSeats(seats: readonly ExpertSeat[]): void;
+/**
+ * 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 declare function parseVerdict(text: string): {
+    verdict: ExpertVerdict["verdict"];
+    confidence: number;
+};
+/**
+ * Run ONE round. All seats are asked concurrently and never see each other's
+ * output, which is what makes the round anonymous.
+ */
+export declare function runRound(opts: DelphiOptions, round: number, system: string, buildPrompt: (seat: ExpertSeat) => string): Promise<RoundResult>;
+//# sourceMappingURL=delphi.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delphi.d.ts","sourceRoot":"","sources":["../src/delphi.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,+DAA+D;AAC/D,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,8EAA8E;IAC9E,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAC5B;AAED,sDAAsD;AACtD,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IACrC,QAAQ,CAAC,OAAO,EAAE,UAAU,GAAG,iBAAiB,GAAG,oBAAoB,GAAG,OAAO,CAAA;IACjF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,4DAA4D;IAC5D,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,uCAAuC;AACvC,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,CAAA;IAC3C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAA;CACnC;AAED,MAAM,WAAW,aAAa;IAC5B,8DAA8D;IAC9D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAA;IACrC,4CAA4C;IAC5C,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;IAClC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B,gEAAgE;IAChE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;IAC7B,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,KAAK,CAAA;CAClC;AAeD,6EAA6E;AAC7E,qBAAa,iBAAkB,SAAQ,KAAK;CAAG;AAE/C;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,GAAG,IAAI,CAoBhE;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG;IAC1C,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,CAAA;IACjC,UAAU,EAAE,MAAM,CAAA;CACnB,CAWA;AA0ID;;;GAGG;AACH,wBAAsB,QAAQ,CAC5B,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,MAAM,GACxC,OAAO,CAAC,WAAW,CAAC,CA8BtB"}

package/plugins/dsh/lib/delphi.js

@@ -0,0 +1,207 @@
+/**
+ * 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
+ */
+/** 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;
+/**
+ * Sampling temperature. Low on purpose: reviewers must apply the rubric the same
+ * way every round, and creativity in a verdict is noise, not signal.
+ */
+const REVIEW_TEMPERATURE = 0.2;
+/** 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) {
+    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) {
+    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 };
+}
+/** Cleanup for a case where no listener was attached, so there is nothing to undo. */
+const NO_CLEANUP = () => undefined;
+/**
+ * Bridge caller cancellation into the controller that also owns the timeout.
+ * Bridging rather than racing two signals means one abort path, so the reason a
+ * request stopped is never ambiguous.
+ */
+function linkAbort(controller, callerSignal) {
+    if (!callerSignal)
+        return NO_CLEANUP;
+    const forwardAbort = () => controller.abort();
+    if (callerSignal.aborted) {
+        controller.abort();
+        return NO_CLEANUP;
+    }
+    callerSignal.addEventListener("abort", forwardAbort, { once: true });
+    return () => callerSignal.removeEventListener("abort", forwardAbort);
+}
+/** Extract the reviewer's text, or explain why there isn't any. */
+function readContent(json, maxTokens) {
+    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=${maxTokens}); ` +
+            `raise max_tokens if this is a reasoning model`);
+    }
+    return { content, resolvedModel: json.model ?? null, finishReason };
+}
+/** Reject a non-2xx answer, keeping the body short enough to read in a verdict. */
+async function ensureOk(res) {
+    if (res.ok)
+        return;
+    const body = await res.text().catch(() => "");
+    throw new Error(`HTTP ${res.status}: ${body.slice(0, 200)}`);
+}
+/** Build the chat-completions request for one seat. */
+function buildRequest(opts, seat, system, user, maxTokens, signal) {
+    return {
+        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: maxTokens,
+            temperature: REVIEW_TEMPERATURE,
+        }),
+        signal,
+    };
+}
+/** One provider call. Throws on transport failure or empty content. */
+async function chatOnce(opts, seat, system, user) {
+    const doFetch = opts.fetchImpl ?? fetch;
+    const controller = new AbortController();
+    const maxTokens = seat.maxTokens ?? DEFAULT_MAX_TOKENS;
+    const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    const unlink = linkAbort(controller, opts.signal);
+    const url = `${opts.baseUrl.replace(/\/+$/, "")}/v1/chat/completions`;
+    try {
+        const request = buildRequest(opts, seat, system, user, maxTokens, controller.signal);
+        const res = await doFetch(url, request);
+        await ensureOk(res);
+        return readContent((await res.json()), maxTokens);
+    }
+    finally {
+        clearTimeout(timer);
+        unlink();
+    }
+}
+/** A seat that failed to answer. Its silence is never counted as agreement. */
+function failedVerdict(seat, reason) {
+    return {
+        id: seat.id,
+        role: seat.role,
+        requestedModel: seat.model,
+        resolvedModel: null,
+        verdict: "ERROR",
+        confidence: 0,
+        counted: false,
+        report: "",
+        error: reason instanceof Error ? reason.message : String(reason),
+    };
+}
+/** A seat that answered: parse its verdict and keep the report as evidence. */
+function answeredVerdict(seat, answer) {
+    const { verdict, confidence } = parseVerdict(answer.content);
+    return {
+        id: seat.id,
+        role: seat.role,
+        requestedModel: seat.model,
+        resolvedModel: answer.resolvedModel,
+        verdict,
+        confidence,
+        counted: verdict !== "INVALID_NO_VERDICT",
+        report: answer.content,
+    };
+}
+/**
+ * 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, round, system, buildPrompt) {
+    const settled = await Promise.allSettled(opts.seats.map(async (seat) => {
+        const r = await chatOnce(opts, seat, system, buildPrompt(seat));
+        return { seat, ...r };
+    }));
+    const verdicts = settled.map((s, i) => {
+        const seat = opts.seats[i];
+        return s.status === "fulfilled"
+            ? answeredVerdict(seat, s.value)
+            : failedVerdict(seat, s.reason);
+    });
+    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,
+    };
+}
+//# sourceMappingURL=delphi.js.map

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

@@ -0,0 +1,24 @@
+/**
+ * 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 declare function shellQuote(value: string, dialect: ShellDialect): string;
+/**
+ * POSIX single-quote shell escaping: `'` becomes `'\''`.
+ * @deprecated Use {@link shellQuote} with an explicit dialect.
+ */
+export declare function shq(value: string): string;
+/**
+ * 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 declare function detectDialect(platform?: NodeJS.Platform): ShellDialect;
+//# sourceMappingURL=dialect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dialect.d.ts","sourceRoot":"","sources":["../src/dialect.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,YAAY,CAAA;AAEjD,iDAAiD;AACjD,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,GAAG,MAAM,CASvE;AAED;;;GAGG;AACH,wBAAgB,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,QAAQ,GAAE,MAAM,CAAC,QAA2B,GAAG,YAAY,CAExF"}

package/plugins/dsh/lib/dialect.js

@@ -0,0 +1,36 @@
+/**
+ * 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.
+ */
+/** Quote one argument for the target dialect. */
+export function shellQuote(value, dialect) {
+    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) {
+    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 = process.platform) {
+    return platform === "win32" ? "powershell" : "posix";
+}
+//# sourceMappingURL=dialect.js.map

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

@@ -0,0 +1,70 @@
+/**
+ * Gate MW walkthrough evidence.
+ *
+ * @test REQ-DSH-012 delphi-review can produce Gate MW evidence
+ * @intent Build the .code-walkthrough-result.json document that the pre-push
+ *         validator accepts, from a review the plugin actually ran.
+ * @covers AC-DSH-012-01
+ *
+ * Every field here mirrors a check in githooks/lib/validate-code-walkthrough.cjs.
+ * Two of those checks are easy to misread and are pinned by test:
+ *
+ *  - result_type belongs to each EXPERT record. Putting it at the top level looks
+ *    right, passes no check, and fails with a message that never mentions placement.
+ *  - requested_model comes from the configured seat, never from the gateway's
+ *    response. The gateway answers with its own naming (Qwen3_8-flash-next for a seat
+ *    configured as local-qwen3.8-flash), so using the response tripped #574.
+ */
+/** The document Gate MW reads. Field names are the validator's, not ours. */
+export interface WalkthroughEvidence {
+    readonly commit: string;
+    readonly branch: string;
+    readonly timestamp: string;
+    readonly expires: string;
+    readonly consensus_ratio: number;
+    readonly verdict: "APPROVED";
+    readonly experts: readonly EvidenceExpert[];
+}
+export interface EvidenceExpert {
+    readonly role: string;
+    readonly requested_model: string;
+    readonly resolved_model: string;
+    /** Per-expert, not top-level. The validator reads it here. */
+    readonly result_type: "delphi_expert_result";
+    readonly channel: "external" | "local";
+    readonly verdict: "APPROVED";
+}
+/** One seat as observed by the review: what we asked for, and what answered. */
+export interface SeatOutcome {
+    readonly role: string;
+    /** The model configured for this role. Becomes requested_model. */
+    readonly model: string;
+    /** The model the gateway reported. Becomes resolved_model. */
+    readonly resolved: string;
+}
+export interface BuildEvidenceInput {
+    readonly head: string;
+    readonly branch: string;
+    readonly seats: readonly SeatOutcome[];
+    readonly verdict: string;
+    readonly now: Date;
+    /** Gateway URL, used to label provenance. */
+    readonly baseUrl?: string;
+    /** Observed agreement. Defaults to unanimous, which is what a 3-seat APPROVED run is. */
+    readonly consensusRatio?: number;
+}
+/**
+ * Label a gateway as local or external.
+ *
+ * Only loopback counts as local: the validator uses this field as provenance, so a
+ * private-network host is still external — nothing about it is verifiable from here.
+ */
+export declare function evidenceChannel(baseUrl: string): "local" | "external";
+/**
+ * Build the evidence document.
+ *
+ * Refuses on anything the validator would reject rather than emitting a document
+ * that fails at push time, where the cause is much harder to see.
+ */
+export declare function buildEvidence(input: BuildEvidenceInput): WalkthroughEvidence;
+//# sourceMappingURL=evidence.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"evidence.d.ts","sourceRoot":"","sources":["../src/evidence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,6EAA6E;AAC7E,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;IAChC,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAA;IAC5B,QAAQ,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,CAAA;CAC5C;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;IAChC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,8DAA8D;IAC9D,QAAQ,CAAC,WAAW,EAAE,sBAAsB,CAAA;IAC5C,QAAQ,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAA;IACtC,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAA;CAC7B;AAED,gFAAgF;AAChF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,mEAAmE;IACnE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,8DAA8D;IAC9D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,CAAA;IACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAA;IAClB,6CAA6C;IAC7C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB,yFAAyF;IACzF,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CACjC;AAWD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,UAAU,CAKrE;AAwBD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,GAAG,mBAAmB,CA8B5E"}

package/plugins/dsh/lib/evidence.js

@@ -0,0 +1,92 @@
+/**
+ * Gate MW walkthrough evidence.
+ *
+ * @test REQ-DSH-012 delphi-review can produce Gate MW evidence
+ * @intent Build the .code-walkthrough-result.json document that the pre-push
+ *         validator accepts, from a review the plugin actually ran.
+ * @covers AC-DSH-012-01
+ *
+ * Every field here mirrors a check in githooks/lib/validate-code-walkthrough.cjs.
+ * Two of those checks are easy to misread and are pinned by test:
+ *
+ *  - result_type belongs to each EXPERT record. Putting it at the top level looks
+ *    right, passes no check, and fails with a message that never mentions placement.
+ *  - requested_model comes from the configured seat, never from the gateway's
+ *    response. The gateway answers with its own naming (Qwen3_8-flash-next for a seat
+ *    configured as local-qwen3.8-flash), so using the response tripped #574.
+ */
+/** The validator requires exactly three seats. */
+const REQUIRED_SEATS = 3;
+/** Evidence is valid for exactly this long; the validator checks the delta. */
+const VALIDITY_MS = 3_600_000;
+/** The validator rejects anything below this. */
+const MIN_CONSENSUS = 0.9;
+/**
+ * Label a gateway as local or external.
+ *
+ * Only loopback counts as local: the validator uses this field as provenance, so a
+ * private-network host is still external — nothing about it is verifiable from here.
+ */
+export function evidenceChannel(baseUrl) {
+    const lowered = baseUrl.toLowerCase();
+    return lowered.includes("localhost") || lowered.includes("127.0.0.1") || lowered.includes("[::1]")
+        ? "local"
+        : "external";
+}
+/** Refuse to emit a document the validator would reject, and say which field. */
+function assertSeatsUsable(seats) {
+    if (seats.length !== REQUIRED_SEATS) {
+        throw new Error(`evidence needs exactly ${REQUIRED_SEATS} seats; got ${seats.length}`);
+    }
+    const requested = new Set();
+    const resolved = new Set();
+    for (const seat of seats) {
+        if (seat.resolved.trim() === "") {
+            throw new Error(`seat "${seat.role}" has no resolved_model; a failed seat cannot produce evidence`);
+        }
+        // Both are checked case-insensitively by some validator paths, so assert on the
+        // stricter reading: duplicated IDs mean one model answered twice.
+        if (requested.has(seat.model.trim()))
+            throw new Error(`duplicate requested_model "${seat.model}"`);
+        if (resolved.has(seat.resolved.trim().toLowerCase())) {
+            throw new Error(`duplicate resolved_model "${seat.resolved}"`);
+        }
+        requested.add(seat.model.trim());
+        resolved.add(seat.resolved.trim().toLowerCase());
+    }
+}
+/**
+ * Build the evidence document.
+ *
+ * Refuses on anything the validator would reject rather than emitting a document
+ * that fails at push time, where the cause is much harder to see.
+ */
+export function buildEvidence(input) {
+    if (input.verdict !== "APPROVED") {
+        throw new Error(`evidence requires an APPROVED review; got ${input.verdict}`);
+    }
+    assertSeatsUsable(input.seats);
+    const ratio = input.consensusRatio ?? 1;
+    if (ratio < MIN_CONSENSUS || ratio > 1) {
+        throw new Error(`consensus_ratio must be ${MIN_CONSENSUS} through 1; got ${ratio}`);
+    }
+    const channel = evidenceChannel(input.baseUrl ?? "");
+    const expires = new Date(input.now.getTime() + VALIDITY_MS);
+    return {
+        commit: input.head,
+        branch: input.branch,
+        timestamp: input.now.toISOString(),
+        expires: expires.toISOString(),
+        consensus_ratio: ratio,
+        verdict: "APPROVED",
+        experts: input.seats.map((seat) => ({
+            role: seat.role,
+            requested_model: seat.model,
+            resolved_model: seat.resolved,
+            result_type: "delphi_expert_result",
+            channel,
+            verdict: "APPROVED",
+        })),
+    };
+}
+//# sourceMappingURL=evidence.js.map