dsh-doublecheck 0.6.0 → 0.7.0

package/lib/guard/index.js

@@ -33,6 +33,8 @@ import { emptyDisciplineState, foldDisciplineRange } from "../domain/stages.js";
 import { isVagueTask } from "../domain/vagueness.js";
 import { runAdversaryReview, reviewInjection } from "./review.js";
 import { PROSE } from "./prose.js";
+import { gateHandler, gateInjection, GateConfigSchema, runGate, settleGate, validateGateConfig, } from "./gate.js";
+import { countRedChecks } from "../domain/gate.js";
 import { applyDoublecheckEvent, emptyDoublecheckState, viewDoublecheck, } from "../domain/projection.js";
 import { doublecheckViewSchema } from "../types.js";
 import { installInvariant, PACKAGE_NAME } from "../invariant.js";
@@ -59,6 +61,7 @@ export const Config = z.object({
     testToolNames: z.array(z.string()).default([...DEFAULT_TEST_TOOL_NAMES]),
     testCommandPatterns: z.array(z.string()).default([...DEFAULT_TEST_COMMAND_PATTERNS]),
     testFilePatterns: z.array(z.string()).default([...DEFAULT_TEST_FILE_PATTERNS]),
+    gate: GateConfigSchema,
 });
 /**
  * Install the guard listeners.
@@ -68,6 +71,7 @@ export const Config = z.object({
 export function apply(ctx, config) {
     assertPositiveInteger('vagueTaskMaxChars', config.vagueTaskMaxChars);
     assertGuardTools(config.guardTools);
+    validateGateConfig(config.gate);
     if (config.modules.adversary) {
         assertBoundedInteger('adversaryMaxFindings', config.adversaryMaxFindings, 20);
         assertPositiveInteger('adversaryTimeoutMs', config.adversaryTimeoutMs);
@@ -130,6 +134,9 @@ export function apply(ctx, config) {
                     snapshot.lastReviewSeq = event.seq;
                     snapshot.editsAfterReview = 0;
                 }
+                else if (source.kind === 'doublecheck-gate') {
+                    snapshot.gateRedReminded = true;
+                }
                 else if (source.kind === 'user') {
                     const parts = [];
                     for (const block of event.data.content) {
@@ -146,6 +153,14 @@ export function apply(ctx, config) {
             else if (event.type === 'doublecheck/state') {
                 snapshot.stateEnabled = event.data.enabled;
             }
+            else if (event.type === 'doublecheck/gate') {
+                const gate = event.data;
+                snapshot.lastGate = {
+                    seq: event.seq,
+                    verdict: gate.verdict,
+                    redCount: gate.phases === undefined ? 0 : countRedChecks(Object.values(gate.phases)),
+                };
+            }
             else if (event.type === 'tool/call' && event.seq > snapshot.lastReviewSeq) {
                 // Implementation edits after the latest review re-arm the adversary
                 // trigger for a second review round.
@@ -173,6 +188,8 @@ export function apply(ctx, config) {
             reportReminded: false,
             lastReviewSeq: -1,
             editsAfterReview: 0,
+            lastGate: null,
+            gateRedReminded: false,
         };
         foldEvents(snapshot, events, 0, events.length);
         snapshots.set(session, snapshot);
@@ -237,8 +254,66 @@ export function apply(ctx, config) {
             setLocalOverride: (session, enabled) => localOverrides.set(session, enabled),
         }),
     });
+    // The delivery gate panel: `/gate` stays available even when the gate or
+    // every discipline module is off — it is the user's inspection surface.
+    ctx.commands.register({
+        name: 'gate',
+        description: 'run the delivery quality gate and report the deliverable/rework decision',
+        input: { hint: 'status|run|config' },
+        handler: gateHandler({
+            config: config.gate,
+            detection,
+            prose,
+            runGate: (agent, signal) => runGate(ctx, config.gate, detection, agent, signal, config.language),
+            settleGate: (state, agent, signal) => settleGate(ctx, config.gate, state, agent, signal, hostStampsIgnorable()),
+            stampsIgnorable: hostStampsIgnorable,
+            planMode: ctx.get('planMode'),
+        }),
+    });
+    // The gate settings namespace: the pluggable checklist becomes editable
+    // through the harness settings surface when one is mounted (weak seam —
+    // a profile without the settings service simply has no settings page).
+    const settings = ctx.get('settings');
+    if (settings !== undefined) {
+        try {
+            settings.register('doublecheck.gate', GateConfigSchema, {
+                base: config.gate,
+                applies: 'restart',
+                expose: true,
+            });
+        }
+        catch (error) {
+            ctx.logger.warn(`dsh-doublecheck: gate settings namespace skipped: ${String(error)}`);
+        }
+    }
+    // The gate-red turn notice: once per session, a settled rework verdict
+    // suggests re-opening the work in plan mode. Installed even when every
+    // discipline module is off — the gate panel is advisory, not a gate.
+    if (config.gate.enabled) {
+        ctx.on('agent/turn-stopping', async ({ agent }) => {
+            if (!doublecheckEnabled(agent.session))
+                return;
+            const snapshot = snapshotOf(agent.session);
+            if (snapshot.gateRedReminded)
+                return;
+            const gate = snapshot.lastGate;
+            if (gate === null || gate.verdict !== 'rework')
+                return;
+            snapshot.gateRedReminded = true;
+            const text = prose.gateRedNotice(gate.redCount);
+            agent.inject(gateInjection(gate.verdict, gate.redCount, text));
+            ctx.emit('doublecheck/reminder', {
+                agent,
+                session: agent.session,
+                intensity: config.intensity,
+                gate: 'gate',
+                verdict: 'gate-red',
+                reminder: text,
+            });
+        });
+    }
     if (!config.modules.grill && !config.modules.tdd && !config.modules.adversary) {
-        ctx.logger.info('dsh-doublecheck: all discipline gates disabled; only the /doublecheck command remains active');
+        ctx.logger.info('dsh-doublecheck: all discipline gates disabled; the /doublecheck and /gate commands remain active');
         return;
     }
     // The policy gate. Observe-and-decide: the grill gate owns vague,
@@ -456,7 +531,7 @@ export function apply(ctx, config) {
             init: emptyDoublecheckState,
             apply: (state, event) => applyDoublecheckEvent(state, event, detection),
             view: viewDoublecheck,
-            stateVersion: 1,
+            stateVersion: 2,
         });
     });
     // The invariant companion, registered from the main plugin so its checks

package/lib/guard/prose.d.ts

@@ -38,6 +38,18 @@ export interface GuardProse {
     reviewHeldBack: (held: number) => string;
     /** The critic's task prompt (model-facing behavior of the review run). */
     criticTask: string;
+    /** The gate-red notice injected at the turn boundary (role statement first). */
+    gateRedNotice: (redCount: number) => string;
+    /** The localized `/gate status` panel header. */
+    gateStatusHeader: string;
+    /** The localized `/gate status` usage hint. */
+    gateStatusHint: string;
+    /** The localized `/gate config` header. */
+    gateConfigHeader: string;
+    /** The localized `/gate` usage error. */
+    gateCommandUnknown: (input: string) => string;
+    /** The localized `/gate` no-agent error. */
+    gateCommandNoAgent: string;
     switchOnDurable: string;
     switchOnLocal: string;
     switchOffDurable: string;
@@ -76,6 +88,11 @@ export interface CommandStatusFacts {
     reviewed: boolean;
     /** Total implementation edits folded so far. */
     editCount: number;
+    /** The latest durable gate run, or null before any. */
+    gate: {
+        verdict: string;
+        redCount: number;
+    } | null;
 }
 /** The localized prose tables by language. */
 export declare const PROSE: Readonly<Record<ProseLanguage, GuardProse>>;

package/lib/guard/prose.js

@@ -74,6 +74,12 @@ const EN = {
         + 'what in the session supports it. If — and only if — the evidence '
         + 'genuinely satisfies every dimension, return an empty findings list. Do '
         + 'not invent objections; the empty answer is correct when nothing is wrong.',
+    gateRedNotice: redCount => `You are the delivery gate panel for this session. The latest gate run is RED with ${redCount} red item(s). Re-open the work in plan mode to re-check, or run /gate run for the full checklist.`,
+    gateStatusHeader: 'Delivery gate panel — checklist progress for this session:',
+    gateStatusHint: 'Deterministic phases fold live; the reviewer phases show the latest /gate run. Run /gate run to settle everything; /gate config shows the checklist.',
+    gateConfigHeader: 'Delivery gate configuration for this session:',
+    gateCommandUnknown: input => `Unknown /gate argument "${input}". Usage: /gate status|run|config`,
+    gateCommandNoAgent: '/gate needs an agent session to inspect.',
     switchOnDurable: 'Double-check discipline was switched ON for this session (changed by the user): the requirements grill, the red/green gates, and the delivery review are active again.',
     switchOnLocal: 'Double-check discipline was switched ON for this process only (changed by the user; this harness build predates the ignorable append surface, so the switch is not durable): the requirements grill, the red/green gates, and the delivery review are active again.',
     switchOffDurable: 'Double-check discipline was switched OFF for this session (changed by the user): the discipline gates defer to the human approval chain until switched back on.',
@@ -91,6 +97,7 @@ const EN = {
         `Modules: grill=${facts.modules.grill ? 'on' : 'off'}, tdd=${facts.modules.tdd ? 'on' : 'off'}, adversary=${facts.modules.adversary ? 'on' : 'off'} (cordis.yml).`,
         `Intensity: ${facts.intensity}. Default switch: ${facts.defaultEnabled ? 'on' : 'off'}. remindOnce: ${facts.remindOnce ? 'on' : 'off'}.`,
         `Stage: spec=${facts.hasSpec ? 'committed' : 'missing'}, tests=${facts.color}, review=${facts.reviewed ? 'on record' : 'not run'}, edits=${facts.editCount}.`,
+        `Gate: ${facts.gate === null ? 'not run' : `${facts.gate.verdict} (${facts.gate.redCount} red item(s))`} (/gate status|run|config).`,
         `Usage: /doublecheck status|report|on|off`,
     ].join('\n'),
 };
@@ -121,6 +128,12 @@ const ZH = {
         + '验收标准、范围或非目标被违反、未处理的失败模式。通过要求的结构化输出作答，'
         + '每条反对意见占一项，并引用会话中支撑它的内容。当且仅当证据确实满足每一个维度时，'
         + '才返回空的 findings 列表。不要编造反对意见；没有问题时空答案才是正确的。',
+    gateRedNotice: redCount => `你是本会话的交付门禁面板。最近一次门禁结论为红灯，共 ${redCount} 项红灯。建议转 plan mode 复查，或运行 /gate run 查看完整检查单。`,
+    gateStatusHeader: '交付门禁面板 — 本会话的检查单进度：',
+    gateStatusHint: '确定性阶段实时折叠；评审类阶段显示最近一次 /gate run 的结果。运行 /gate run 结算全部检查；/gate config 查看检查单配置。',
+    gateConfigHeader: '本会话的交付门禁配置：',
+    gateCommandUnknown: input => `未知的 /gate 参数 "${input}"。用法：/gate status|run|config`,
+    gateCommandNoAgent: '/gate 需要代理会话才能查看。',
     switchOnDurable: 'Double-check 纪律已对本会话开启（由用户切换）：需求盘问、红绿门和交付审查恢复生效。',
     switchOnLocal: 'Double-check 纪律已对本进程开启（由用户切换；此 harness 版本早于 ignorable 追加接口，切换不持久）：需求盘问、红绿门和交付审查恢复生效。',
     switchOffDurable: 'Double-check 纪律已对本会话关闭（由用户切换）：在重新开启之前，纪律门让位于人工审批链。',
@@ -138,6 +151,7 @@ const ZH = {
         `模块：grill=${facts.modules.grill ? '开' : '关'}, tdd=${facts.modules.tdd ? '开' : '关'}, adversary=${facts.modules.adversary ? '开' : '关'}（cordis.yml）。`,
         `强度：${facts.intensity}。默认开关：${facts.defaultEnabled ? '开' : '关'}。remindOnce：${facts.remindOnce ? '开' : '关'}。`,
         `阶段：spec=${facts.hasSpec ? '已提交' : '缺失'}, tests=${facts.color}, review=${facts.reviewed ? '有记录' : '未运行'}, edits=${facts.editCount}。`,
+        `门禁：${facts.gate === null ? '未运行' : `${facts.gate.verdict}（${facts.gate.redCount} 项红灯）`}（/gate status|run|config）。`,
         '用法：/doublecheck status|report|on|off',
     ].join('\n'),
 };

package/lib/index.d.ts

@@ -12,6 +12,7 @@ export * from './domain/evidence.ts';
 export * from './domain/vagueness.ts';
 export * from './domain/vocabulary.ts';
 export * from './domain/report.ts';
+export * from './domain/gate.ts';
 export { renderSpecMarkdown } from './grill/index.ts';
 export { BundledSkillProvider, parseSkillAsset, PROVIDER_NAME } from './grill/provider.ts';
 export type * from './types.ts';

package/lib/index.js

@@ -11,5 +11,6 @@ export * from "./domain/evidence.js";
 export * from "./domain/vagueness.js";
 export * from "./domain/vocabulary.js";
 export * from "./domain/report.js";
+export * from "./domain/gate.js";
 export { renderSpecMarkdown } from "./grill/index.js";
 export { BundledSkillProvider, parseSkillAsset, PROVIDER_NAME } from "./grill/provider.js";

package/lib/invariant.d.ts

@@ -14,6 +14,8 @@
  *    the tool result, not this event, so equality is not checkable there).
  * 3. Every `doublecheck/review` announcement's findings satisfy the
  *    structured finding shape (severity enum, non-empty title and detail).
+ * 4. Every `doublecheck/gate` announcement's verdict matches the re-derivation
+ *    from its own phase results, and all four phases are present.
  *
  * The guard registers a facts-bearing installer from its own context; the
  * `./invariant` export is the standalone companion usable through a separate

package/lib/invariant.js

@@ -14,6 +14,8 @@
  *    the tool result, not this event, so equality is not checkable there).
  * 3. Every `doublecheck/review` announcement's findings satisfy the
  *    structured finding shape (severity enum, non-empty title and detail).
+ * 4. Every `doublecheck/gate` announcement's verdict matches the re-derivation
+ *    from its own phase results, and all four phases are present.
  *
  * The guard registers a facts-bearing installer from its own context; the
  * `./invariant` export is the standalone companion usable through a separate
@@ -22,6 +24,7 @@
  */
 import { SPEC_FIELD_NAMES } from "./domain/vocabulary.js";
 import { deriveReportVerdict, foldReportFacts } from "./domain/report.js";
+import { deriveGateVerdict, GATE_PHASES } from "./domain/gate.js";
 /** Full npm package name owning the reported failures. */
 export const PACKAGE_NAME = 'dsh-doublecheck';
 /** Cordis companion plugin name. */
@@ -80,6 +83,18 @@ export function installInvariant(facts) {
                 }
             }
         });
+        ctx.on('doublecheck/gate', (payload) => {
+            const state = payload.state;
+            const derived = deriveGateVerdict(GATE_PHASES.map(phase => state.phases[phase]).filter(phase => phase !== undefined));
+            if (derived !== state.verdict) {
+                fail(`doublecheck/gate announces verdict "${state.verdict}" but its phases derive "${derived}"`);
+            }
+            for (const phase of GATE_PHASES) {
+                if (state.phases[phase] === undefined) {
+                    fail(`doublecheck/gate carries no "${phase}" phase result`);
+                }
+            }
+        });
     };
 }
 /**

package/lib/types.d.ts

@@ -8,6 +8,7 @@
  */
 import { z as zod } from 'zod';
 import type { DisciplineStage, TestColor } from './domain/stages.ts';
+import type { GateVerdict } from './domain/gate.ts';
 /** The whole wire value of the `doublecheck` session projection. */
 export interface DoublecheckView {
     /** The last discipline stage reached on durable evidence. */
@@ -22,6 +23,10 @@ export interface DoublecheckView {
     reviewed: boolean;
     /** Total implementation edits folded so far. */
     editCount: number;
+    /** The latest delivery-gate verdict, or 'none' before any gate run. */
+    gateVerdict: 'none' | GateVerdict;
+    /** Red-light (failing) checks of the latest gate run. */
+    gateRedCount: number;
 }
 /** Validates the `doublecheck` projection's wire payload before it leaves the host. */
 export declare const doublecheckViewSchema: zod.ZodObject<{
@@ -31,6 +36,8 @@ export declare const doublecheckViewSchema: zod.ZodObject<{
     specGoal: zod.ZodString;
     reviewed: zod.ZodBoolean;
     editCount: zod.ZodNumber;
+    gateVerdict: zod.ZodUnion<readonly [zod.ZodLiteral<"none">, zod.ZodLiteral<"deliverable">, zod.ZodLiteral<"rework">]>;
+    gateRedCount: zod.ZodNumber;
 }, zod.core.$strip>;
 declare module '@deepseek-ai/dsh-session-projection/types' {
     interface SessionProjectionMap {

package/lib/types.js

@@ -15,4 +15,6 @@ export const doublecheckViewSchema = zod.object({
     specGoal: zod.string(),
     reviewed: zod.boolean(),
     editCount: zod.number(),
+    gateVerdict: zod.union([zod.literal('none'), zod.literal('deliverable'), zod.literal('rework')]),
+    gateRedCount: zod.number(),
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-doublecheck",
-  "version": "0.6.0",
-  "description": "Double-check before you ship: grill the requirements, test the implementation, prove the delivery.",
+  "version": "0.7.0",
+  "description": "Delivery quality gate for DeepSeek Harness: grill the requirements, test the implementation, prove the delivery, and gate the handoff with a deliverable/rework decision.",
   "packageManager": "pnpm@11.7.0",
   "repository": {
     "type": "git",
@@ -67,7 +67,9 @@
     "engineering-discipline",
     "requirements",
     "guard",
-    "skill"
+    "skill",
+    "quality-gate",
+    "delivery-gate"
   ],
   "author": "PerryLink",
   "license": "Apache-2.0",
@@ -79,6 +81,45 @@
       "patch": "./cordis.patch.yml"
     }
   },
+  "dshWorkshop": {
+    "schema": "omdsh-workshop-package/v1",
+    "type": "plugin",
+    "integration": {
+      "protocol": "harness-profile",
+      "artifact": "cordis.patch.yml"
+    },
+    "install": {
+      "mode": "transactional",
+      "adapter": "profile-bundle",
+      "failurePolicy": "generation-rollback",
+      "touchesCurrentBeforeActivation": false
+    },
+    "lifecycle": {
+      "activation": "restart-profile",
+      "dispose": "supported"
+    },
+    "permissions": [
+      "filesystem:read",
+      "filesystem:write"
+    ],
+    "compatibility": {
+      "dshVersions": [
+        "0.1.0-rc.6"
+      ]
+    },
+    "capability": {
+      "id": "doublecheck",
+      "kind": "command",
+      "invocation": "send /gate status in a session with the plugin rows loaded",
+      "expected": "a reply reporting the live checklist progress (requirements/test evidence phases), the latest gate run verdict with red items, and the plan-mode state"
+    },
+    "evidence": {
+      "install": null,
+      "failureIsolation": null,
+      "hotReload": null,
+      "remove": null
+    }
+  },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/dsh-agent": "0.1.0-rc.6",

package/skills/delivery-proof/SKILL.md

@@ -32,6 +32,18 @@ for a proof, a delivery summary, or a "what did we actually do" record.
    proven and must not be described as such; `unverified` means not every
    dimension returned a verdict.
 
+## Passing the delivery gate
+
+Before claiming the delivery is ready to ship, run the quality gate:
+
+1. Run `/gate run`. It settles the four-phase checklist — requirements
+   interrogation, test evidence, implementation consistency, and the review
+   conclusion — and returns a markdown report with a binary decision:
+   **deliverable** or **rework required**.
+2. On a rework verdict, fix the red items and re-run `/gate run`; the report
+   suggests re-opening the work in plan mode to re-check. Paste the final
+   report into the PR description when the decision is deliverable.
+
 ## Reading the verdict
 
 - **grill / draft / red** — the discipline loop is not complete. State what

package/strict.patch.yml

@@ -31,3 +31,40 @@
     testFilePatterns:
       - '(^|[\\/])(tests?|__tests__|specs?)([\\/]|$)'
       - '\\.(test|spec)\\.[A-Za-z0-9]+$'
+    gate:
+      enabled: true
+      planSuggestion: true
+      reportFile: 'gate-report.md'
+      requirements:
+        enabled: true
+        checklist:
+          - { id: goal, question: 'What outcome must the delivery produce?', specDimension: goal, required: true }
+          - { id: scope, question: 'What is in scope, and what is out of scope?', specDimension: scope, required: true }
+          - { id: acceptance, question: 'Which observable checks prove the work is done?', specDimension: acceptanceCriteria, required: true }
+          - { id: failureModes, question: 'What can go wrong, and what is the correct behavior in each case?', specDimension: failureModes, required: true }
+          - { id: priorities, question: 'What is traded when goals conflict; what is optional?', specDimension: priorities, required: true }
+          - { id: nonGoals, question: 'What does the user explicitly not want?', specDimension: nonGoals, required: true }
+        minConfirmed: 6
+        interrogateTool: 'ask_user_question'
+      tests:
+        enabled: true
+        requirePassingRun: true
+        allowFailingRuns: 0
+        requireCoverage: true
+        minCoveragePct: 80
+        coveragePattern: 'coverage[^\\d]{0,40}(\\d+(?:\\.\\d+)?)\\s*%'
+      consistency:
+        enabled: true
+        provider: fork
+        model: null
+        tools: ['read', 'glob', 'grep']
+        timeoutMs: 120000
+        maxFindings: 5
+      review:
+        enabled: true
+        engine: auto
+        provider: fork
+        model: null
+        tools: ['read', 'glob', 'grep']
+        timeoutMs: 120000
+        maxFindings: 5