dsh-doublecheck 0.5.0

package/lib/domain/vocabulary.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Shared discipline vocabulary: the durable structured facts the review and
+ * report modules exchange. Kept type-only and import-cycle-free so events,
+ * domain folds, and tool implementations all read the same definitions.
+ *
+ * @module dsh-doublecheck/domain/vocabulary
+ */
+/** The six dimensions of a grilled requirements spec (v0.1 canonical fields). */
+export interface GrilledSpec {
+    /** What outcome the work must produce, in one verifiable sentence. */
+    goal: string;
+    /** What is in scope and what is out of scope for this change. */
+    scope: string;
+    /** Observable checks that prove the work is done. */
+    acceptanceCriteria: string;
+    /** What can go wrong and the correct behavior in each case. */
+    failureModes: string;
+    /** What to trade when goals conflict; what is optional. */
+    priorities: string;
+    /** What the user explicitly does not want. */
+    nonGoals: string;
+}
+/** One structured objection from the adversary review. */
+export interface ReviewFinding {
+    /** How much the finding threatens the delivery claim. */
+    severity: 'blocker' | 'major' | 'minor' | 'info';
+    /** One-line statement of the objection. */
+    title: string;
+    /** The evidence in the session that supports the objection. */
+    detail: string;
+}
+/** What the adversary review concluded. */
+export type ReviewVerdict = 'findings' | 'clean' | 'unavailable';
+/** The derived delivery status of a doublecheck report. */
+export type ReportVerdict = 'grill' | 'draft' | 'red' | 'green' | 'objections' | 'verified' | 'proven' | 'challenged' | 'unverified';
+/** One dimension checked by the verify workflow. */
+export type VerifyDimension = 'goal' | 'scope' | 'acceptanceCriteria' | 'failureModes' | 'priorities' | 'nonGoals';
+/** All verify dimensions, in spec order. */
+export declare const VERIFY_DIMENSIONS: readonly VerifyDimension[];
+/** One settled verification check. */
+export interface VerifyCheck {
+    /** The spec dimension this check examined. */
+    dimension: VerifyDimension;
+    /** Whether the delivery satisfies this dimension on the session evidence. */
+    verdict: 'pass' | 'fail';
+    /** What in the session supports the verdict. */
+    evidence: string;
+    /** Optional note about what to fix or re-examine. */
+    note: string;
+}

package/lib/domain/vocabulary.js

@@ -0,0 +1,16 @@
+/**
+ * Shared discipline vocabulary: the durable structured facts the review and
+ * report modules exchange. Kept type-only and import-cycle-free so events,
+ * domain folds, and tool implementations all read the same definitions.
+ *
+ * @module dsh-doublecheck/domain/vocabulary
+ */
+/** All verify dimensions, in spec order. */
+export const VERIFY_DIMENSIONS = [
+    'goal',
+    'scope',
+    'acceptanceCriteria',
+    'failureModes',
+    'priorities',
+    'nonGoals',
+];

package/lib/events.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Package-internal Cordis event vocabulary.
+ *
+ * These events are process-local notifications between dsh-doublecheck's own
+ * plugin modules. Durable state never depends on them: the session log
+ * (`tool/call` / `tool/result` / `user/message` events) remains the single
+ * source of truth, and every model-visible payload they announce is recorded
+ * there through the standard channels before the event fires. Structured
+ * discipline facts that must survive the conversation ride the durable log as
+ * injected `user/message` sources via the {@link MessageSourceMap} extension
+ * below — never as these process-local events.
+ *
+ * @module dsh-doublecheck/events
+ */
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { Session, SessionEventMap } from '@deepseek-ai/dsh-session';
+import type { GrilledSpec, ReviewFinding, ReviewVerdict, ReportVerdict, VerifyCheck } from './domain/vocabulary.ts';
+export type { GrilledSpec, ReviewFinding, ReviewVerdict, ReportVerdict, VerifyCheck } from './domain/vocabulary.ts';
+/** Guard enforcement strength. */
+export type GuardIntensity = 'remind' | 'warn' | 'block';
+/** Which discipline gate produced a guard reaction. */
+export type GuardGate = 'grill' | 'tdd' | 'delivery';
+/** Policy outcome of one guard reaction. */
+export type GuardVerdict = 'reminded' | 'held' | 'denied' | 'green-pending' | 'report-expected';
+declare module '@deepseek-ai/dsh-session' {
+    interface SessionEventMap {
+        /**
+         * The per-session master switch written by `/doublecheck on|off`: when
+         * false, all discipline gates (grill, tdd, adversary) defer to the human
+         * chain for this session, surviving restart and restore. The event rides
+         * the envelope's `ignorable: true` marker so hosts that do not know the
+         * type still load the log.
+         */
+        'doublecheck/state': {
+            enabled: boolean;
+        };
+    }
+}
+/**
+ * `Session.append` narrowed to the `doublecheck/state` event. The options bag
+ * carries `ignorable: true`; rc.6 hosts ignore it (same event), post-rc.6
+ * hosts stamp the marker.
+ */
+export interface StateAppend {
+    (type: 'doublecheck/state', data: SessionEventMap['doublecheck/state'], options: {
+        ignorable: true;
+    }): void;
+}
+declare module '@deepseek-ai/dsh-llm' {
+    interface MessageSourceMap {
+        /**
+         * The adversary review injected into the session: the durable record of
+         * one settled critique. The model-facing text is the rendered findings
+         * (or clean/unavailable notice); the structured findings and verdict live
+         * here so the doublecheck report can fold them without re-parsing prose.
+         */
+        'doublecheck-review': {
+            kind: 'doublecheck-review';
+            verdict: ReviewVerdict;
+            findings: ReviewFinding[];
+        };
+    }
+}
+declare module '@deepseek-ai/cordis' {
+    interface Events {
+        /**
+         * The grill module committed a requirements spec: the canonical spec was
+         * returned to the model (and recorded as a `tool/result` session event)
+         * and the workspace copy write settled. Future discipline modules consume
+         * this notification to advance the shared stage state machine.
+         * @param payload.session - the session the spec belongs to.
+         * @param payload.spec - the six committed spec fields.
+         * @param payload.path - absolute workspace path written, or null when no write happened.
+         * @param payload.written - whether the markdown copy reached the workspace.
+         * @mode emit
+         */
+        'doublecheck/spec'(payload: {
+            session: Session;
+            spec: GrilledSpec;
+            path: string | null;
+            written: boolean;
+        }): void;
+        /**
+         * The discipline guard reacted: the grill gate hit a requirements-less
+         * mutation attempt, the red gate hit an implementation edit without a
+         * failing test on record, or the green gate noticed edits without a
+         * passing test run at turn end. Reminders queued here ride the standard
+         * context channel into the session log; held/denied outcomes happened at
+         * the policy gate. Observability only — listeners must not veto or reroute.
+         * @param payload.agent - the calling agent, when the call has one.
+         * @param payload.session - the session the call belongs to.
+         * @param payload.toolName - the intercepted mutation tool; absent for green-gate reactions.
+         * @param payload.intensity - the configured enforcement strength.
+         * @param payload.gate - the discipline gate that produced this reaction.
+         * @param payload.verdict - the policy outcome produced by this reaction.
+         * @param payload.reminder - the reminder prose, when one was queued.
+         * @mode emit
+         */
+        'doublecheck/reminder'(payload: {
+            agent: Agent | undefined;
+            session: Session;
+            toolName?: string;
+            intensity: GuardIntensity;
+            gate: GuardGate;
+            verdict: GuardVerdict;
+            reminder?: string;
+        }): void;
+        /**
+         * The adversary module settled one delivery review: a forked critic
+         * subagent compared the committed spec against the session's delivery
+         * evidence and produced structured findings (or a clean/unavailable
+         * verdict). The review text that reached the model rides the standard
+         * injection channel and is recorded as a `user/message` session event
+         * whose source carries the structured record. Observability only —
+         * listeners must not veto or reroute.
+         * @param payload.session - the reviewed session.
+         * @param payload.agent - the reviewed agent.
+         * @param payload.verdict - findings, clean, or unavailable.
+         * @param payload.findings - the structured objections, when the critic produced any.
+         * @param payload.text - the model-facing review prose, when one was injected.
+         * @mode emit
+         */
+        'doublecheck/review'(payload: {
+            session: Session;
+            agent: Agent;
+            verdict: ReviewVerdict;
+            findings: ReviewFinding[];
+            text?: string;
+        }): void;
+        /**
+         * The doublecheck report tool committed a consolidated delivery report:
+         * the folded session facts, the derived verdict, the optional
+         * verification checks with their completeness flag, and the workspace
+         * copy outcome. The report the model sees is the tool's own
+         * `tool/result`; this event is observability only — listeners must not
+         * veto or reroute.
+         * @param payload.session - the reported session.
+         * @param payload.verdict - the derived delivery status.
+         * @param payload.verification - the verification checks and completeness, when verification ran.
+         * @param payload.path - absolute workspace path written, or null when no write happened.
+         * @param payload.written - whether the markdown copy reached the workspace.
+         * @mode emit
+         */
+        'doublecheck/report'(payload: {
+            session: Session;
+            verdict: ReportVerdict;
+            verification: {
+                checks: VerifyCheck[];
+                complete: boolean;
+            } | null;
+            path: string | null;
+            written: boolean;
+        }): void;
+    }
+}

package/lib/events.js

@@ -0,0 +1,15 @@
+/**
+ * Package-internal Cordis event vocabulary.
+ *
+ * These events are process-local notifications between dsh-doublecheck's own
+ * plugin modules. Durable state never depends on them: the session log
+ * (`tool/call` / `tool/result` / `user/message` events) remains the single
+ * source of truth, and every model-visible payload they announce is recorded
+ * there through the standard channels before the event fires. Structured
+ * discipline facts that must survive the conversation ride the durable log as
+ * injected `user/message` sources via the {@link MessageSourceMap} extension
+ * below — never as these process-local events.
+ *
+ * @module dsh-doublecheck/events
+ */
+export {};

package/lib/grill/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The grill module: dsh-doublecheck's requirements-furnace plugin.
+ *
+ * Registers the bundled `skills/` directory on the DSH skill registry (the
+ * official skill capability seam), exposes the model-facing catalog/loader
+ * tool `doublecheck_skills`, and provides the two contract tools:
+ * `doublecheck_spec` (commit a grilled requirements spec to the session log
+ * and a workspace markdown file) and `doublecheck_report` (v0.4: consolidate
+ * the session's discipline evidence into a delivery report, optionally
+ * orchestrating a per-dimension verification workflow through the DSH
+ * workflow seam).
+ *
+ * @module dsh-doublecheck/grill
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type Schema from '@deepseek-ai/schemastery';
+import type { GrilledSpec } from '../events.ts';
+export declare const name = "doublecheck-grill";
+export declare const inject: string[];
+/** Grill module configuration. */
+export interface Config {
+    /** Workspace file (relative to the session cwd) that receives the spec markdown. */
+    specFile: string;
+    /** Workspace file (relative to the session cwd) that receives the report markdown. */
+    reportFile: string;
+    /** Whether the report runs the verify workflow when the caller does not choose. */
+    reportVerify: boolean;
+    /** Subagent provider the verify workflow's checkers run on. */
+    verifyProvider: string;
+    /** Checker fan-out: one parallel checker per dimension (`all`) or one combined checker (`single`). */
+    verifyMode: 'all' | 'single';
+    /** Report-scoped knobs: shell tools whose commands may be test runs. */
+    reportTestToolNames: string[];
+    /** Report-scoped knobs: commands that count as test runs. */
+    reportTestCommandPatterns: string[];
+    /** Report-scoped knobs: mutation tools counted as implementation edits. */
+    reportMutationTools: string[];
+    /** Report-scoped knobs: paths identifying test files (not implementation edits). */
+    reportTestFilePatterns: string[];
+}
+export declare const Config: Schema<Config>;
+/** The rendered spec document written to the workspace and shown to the model. */
+export declare function renderSpecMarkdown(spec: GrilledSpec): string;
+/**
+ * Install the grill module: bundled skill provider plus its three tools.
+ * @param ctx - plugin context; registrations unwind with it.
+ * @param config - validated {@link Config}.
+ */
+export declare function apply(ctx: Context, config: Config): void;