dsh-doublecheck 0.5.0

package/lib/guard/review.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Adversary review: a forked critic subagent audits the delivery against the
+ * committed spec.
+ *
+ * The critic is a one-shot `ctx.subagents` run on the configured provider
+ * (default `fork`): the child inherits the parent session's completed-turn
+ * prefix, so it sees the `doublecheck_spec` record, the red/green test
+ * evidence, and every edit without any extra plumbing. A structured output
+ * schema forces the findings shape; `agentOptions.model` routes the critic to
+ * `adversaryModel` when one is configured. The critic may read (never mutate)
+ * through an explicit tool allowlist.
+ *
+ * @module dsh-doublecheck/guard/review
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { UserMessage } from '@deepseek-ai/dsh-llm';
+import type { ObjectJsonSchema } from '@deepseek-ai/dsh-tools';
+import type { ReviewFinding, ReviewVerdict } from '../domain/vocabulary.ts';
+import { type GuardProse, type ProseLanguage } from './prose.ts';
+/** The adversary knobs the review runner reads. */
+export interface AdversaryConfig {
+    adversaryProvider: string;
+    adversaryModel: string | null;
+    adversaryMaxFindings: number;
+    adversaryTools: string[];
+    adversaryTimeoutMs: number;
+    /** Language of the injected review prose. */
+    language: ProseLanguage;
+}
+/** The settled outcome of one review run, ready for injection. */
+export interface ReviewOutcome {
+    verdict: ReviewVerdict;
+    findings: ReviewFinding[];
+    /** Model-facing prose for the injection channel. */
+    text: string;
+}
+/**
+ * Structured output the critic must satisfy: a findings list whose entries
+ * carry a severity, a one-line title, and the supporting detail.
+ */
+export declare const REVIEW_OUTPUT_SCHEMA: ObjectJsonSchema;
+/** Injected when the critic found nothing supportable (English contract text). */
+export declare const CLEAN_TEXT: string;
+/** Render structured findings as the model-facing review text. */
+export declare function renderFindings(findings: readonly ReviewFinding[], prose?: GuardProse, totalCount?: number): string;
+/**
+ * Run one adversary review for the given agent and settle it to an
+ * injectable outcome. Failures of the review mechanism itself (provider
+ * missing, run aborted, model failure) settle as `unavailable` with an
+ * honest notice instead of blocking the turn boundary on a broken critic.
+ * @param ctx - plugin context carrying the subagents seam.
+ * @param config - the adversary knobs.
+ * @param agent - the reviewed agent; its session seeds the forked critic.
+ * @param turnSignal - the turn's abort signal; cancelling the turn cancels
+ * the review instead of letting it run out the timeout.
+ * @returns the settled review outcome.
+ */
+export declare function runAdversaryReview(ctx: Context, config: AdversaryConfig, agent: Agent, turnSignal?: AbortSignal): Promise<ReviewOutcome>;
+/**
+ * The injected review message: model-facing prose with the structured
+ * findings riding the durable `doublecheck-review` message source, so the
+ * doublecheck report can fold the record without re-parsing the prose.
+ * @param outcome - the settled review outcome.
+ * @returns the injection-ready user message.
+ */
+export declare function reviewInjection(outcome: ReviewOutcome): UserMessage;

package/lib/guard/review.js

@@ -0,0 +1,184 @@
+/**
+ * Adversary review: a forked critic subagent audits the delivery against the
+ * committed spec.
+ *
+ * The critic is a one-shot `ctx.subagents` run on the configured provider
+ * (default `fork`): the child inherits the parent session's completed-turn
+ * prefix, so it sees the `doublecheck_spec` record, the red/green test
+ * evidence, and every edit without any extra plumbing. A structured output
+ * schema forces the findings shape; `agentOptions.model` routes the critic to
+ * `adversaryModel` when one is configured. The critic may read (never mutate)
+ * through an explicit tool allowlist.
+ *
+ * @module dsh-doublecheck/guard/review
+ */
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { PROSE } from "./prose.js";
+/**
+ * Structured output the critic must satisfy: a findings list whose entries
+ * carry a severity, a one-line title, and the supporting detail.
+ */
+export const REVIEW_OUTPUT_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['findings'],
+    properties: {
+        findings: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['severity', 'title', 'detail'],
+                properties: {
+                    severity: {
+                        type: 'string',
+                        enum: ['blocker', 'major', 'minor', 'info'],
+                    },
+                    title: { type: 'string' },
+                    detail: { type: 'string' },
+                },
+            },
+        },
+    },
+};
+/**
+ * The critic's task, delivered as the forked child's user message. The child
+ * already holds the parent history; this prompt only sets the adversarial
+ * stance and the answer discipline.
+ */
+const CRITIC_TASK = 'You are the delivery reviewer for this software-engineering session. The '
+    + 'conversation you inherited contains a requirements spec recorded with the '
+    + 'doublecheck_spec tool (six dimensions: goal, scope, acceptance criteria, '
+    + 'failure modes, priorities, non-goals), followed by the implementation '
+    + 'work and its test evidence. Assume the delivery FAILS its own spec. Hunt '
+    + 'for the strongest objections you can actually support from this session: '
+    + 'dimensions the work did not meet, acceptance criteria with no evidence, '
+    + 'scope or non-goal violations, failure modes left unhandled. Answer '
+    + 'through the required structured output, one entry per objection, citing '
+    + '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.';
+/** Injected when the critic found nothing supportable (English contract text). */
+export const CLEAN_TEXT = PROSE.en.reviewClean;
+/** Render structured findings as the model-facing review text. */
+export function renderFindings(findings, prose = PROSE.en, totalCount = findings.length) {
+    const lines = [
+        prose.reviewFindingsHeader(findings.length),
+        '',
+    ];
+    for (const finding of findings) {
+        lines.push(`- [${finding.severity}] ${finding.title}`);
+        lines.push(`  ${finding.detail}`);
+    }
+    if (totalCount > findings.length) {
+        lines.push(`… ${totalCount - findings.length} further objection(s) held back by adversaryMaxFindings`);
+    }
+    lines.push('', prose.reviewFindingsFooter);
+    return lines.join('\n');
+}
+/**
+ * Run one adversary review for the given agent and settle it to an
+ * injectable outcome. Failures of the review mechanism itself (provider
+ * missing, run aborted, model failure) settle as `unavailable` with an
+ * honest notice instead of blocking the turn boundary on a broken critic.
+ * @param ctx - plugin context carrying the subagents seam.
+ * @param config - the adversary knobs.
+ * @param agent - the reviewed agent; its session seeds the forked critic.
+ * @param turnSignal - the turn's abort signal; cancelling the turn cancels
+ * the review instead of letting it run out the timeout.
+ * @returns the settled review outcome.
+ */
+export async function runAdversaryReview(ctx, config, agent, turnSignal) {
+    const prose = PROSE[config.language];
+    const subagents = ctx.get('subagents');
+    if (subagents === undefined) {
+        ctx.logger.warn('dsh-doublecheck: adversary review skipped: the ctx.subagents seam is not mounted');
+        return { verdict: 'unavailable', findings: [], text: prose.reviewUnavailableSeam };
+    }
+    const timeout = AbortSignal.timeout(config.adversaryTimeoutMs);
+    const signal = turnSignal === undefined ? timeout : AbortSignal.any([turnSignal, timeout]);
+    let run;
+    try {
+        run = await subagents.start(config.adversaryProvider, {
+            label: 'doublecheck-adversary',
+            prompt: [{ type: 'text', text: CRITIC_TASK }],
+            parent: agent,
+            signal,
+            ...config.adversaryModel !== null ? { agentOptions: { model: config.adversaryModel } } : {},
+            outputSchema: REVIEW_OUTPUT_SCHEMA,
+            toolFilter: { allow: config.adversaryTools },
+        });
+    }
+    catch (error) {
+        // Provider absence, capability rejection, or a child that could not be
+        // composed: the review itself never ran, and the notice says so.
+        return { verdict: 'unavailable', findings: [], text: prose.reviewUnavailableFailed(String(error)) };
+    }
+    try {
+        const result = await settleResult(run, signal, prose, config.adversaryMaxFindings);
+        return result;
+    }
+    finally {
+        await run.dispose();
+    }
+}
+/** Await one critic run; a rejection settles as an honest unavailable notice. */
+async function settleResult(run, signal, prose, maxFindings) {
+    let result;
+    try {
+        result = await run.result;
+    }
+    catch (error) {
+        if (signal.aborted) {
+            return { verdict: 'unavailable', findings: [], text: prose.reviewUnavailableStopped('aborted') };
+        }
+        // A broken critic must not throw into the turn-stopping chain.
+        return { verdict: 'unavailable', findings: [], text: prose.reviewUnavailableFailed(String(error)) };
+    }
+    if (result.stopReason !== 'completed') {
+        return {
+            verdict: 'unavailable',
+            findings: [],
+            text: prose.reviewUnavailableStopped(result.stopReason),
+        };
+    }
+    // The seam validates `structured` against the requested schema before a
+    // completed run settles, so the typed reading needs no re-validation.
+    const structured = result.structured;
+    const raw = structured?.findings;
+    if (!Array.isArray(raw)) {
+        return { verdict: 'unavailable', findings: [], text: outputText(result.output, prose.reviewUnavailableNoFindings) };
+    }
+    const findings = raw.slice(0, maxFindings);
+    if (findings.length === 0)
+        return { verdict: 'clean', findings: [], text: prose.reviewClean };
+    return { verdict: 'findings', findings, text: renderFindings(findings, prose, raw.length) };
+}
+/** Join a result's content blocks, with a fallback line when they are empty. */
+function outputText(content, fallback) {
+    const parts = [];
+    for (const block of content) {
+        if (block.type === 'text')
+            parts.push(block.text);
+    }
+    const text = parts.join('\n').trim();
+    return text.length > 0 ? text : fallback;
+}
+/**
+ * The injected review message: model-facing prose with the structured
+ * findings riding the durable `doublecheck-review` message source, so the
+ * doublecheck report can fold the record without re-parsing the prose.
+ * @param outcome - the settled review outcome.
+ * @returns the injection-ready user message.
+ */
+export function reviewInjection(outcome) {
+    const source = {
+        kind: 'doublecheck-review',
+        verdict: outcome.verdict,
+        findings: outcome.findings,
+    };
+    return createUserMessage({
+        content: [{ type: 'text', text: outcome.text }],
+        source,
+    });
+}

package/lib/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * dsh-doublecheck package entry: the shared domain model and pure helpers.
+ * The installable plugin rows live at the `./grill` and `./guard` subpath
+ * exports (see cordis.patch.yml); this root exists for tools, tests, and
+ * future modules that need the package's private domain vocabulary.
+ *
+ * @module dsh-doublecheck
+ */
+export type { GrilledSpec, GuardIntensity, GuardGate, GuardVerdict } from './events.ts';
+export * from './domain/stages.ts';
+export * from './domain/evidence.ts';
+export * from './domain/vagueness.ts';
+export * from './domain/vocabulary.ts';
+export * from './domain/report.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

@@ -0,0 +1,15 @@
+/**
+ * dsh-doublecheck package entry: the shared domain model and pure helpers.
+ * The installable plugin rows live at the `./grill` and `./guard` subpath
+ * exports (see cordis.patch.yml); this root exists for tools, tests, and
+ * future modules that need the package's private domain vocabulary.
+ *
+ * @module dsh-doublecheck
+ */
+export * from "./domain/stages.js";
+export * from "./domain/evidence.js";
+export * from "./domain/vagueness.js";
+export * from "./domain/vocabulary.js";
+export * from "./domain/report.js";
+export { renderSpecMarkdown } from "./grill/index.js";
+export { BundledSkillProvider, parseSkillAsset, PROVIDER_NAME } from "./grill/provider.js";

package/lib/invariant.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Package-owned invariant companion for dsh-doublecheck.
+ *
+ * Three post-commit diagnostic checks over the events this package's write
+ * paths produce (all three target events are committed before dispatch, so a
+ * violation is reported — via the host registry's `fail` — rather than
+ * vetoed):
+ *
+ * 1. Every `doublecheck/spec` announcement carries six non-empty spec fields.
+ * 2. Every `doublecheck/report` announcement's verdict is consistent with the
+ *    log re-derivation. When verification did not run, the two must be equal;
+ *    when verification ran, a failing check must report `challenged` and a
+ *    clean one must report `proven` or `unverified` (the `complete` fact rides
+ *    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).
+ *
+ * The guard registers a facts-bearing installer from its own context; the
+ * `./invariant` export is the standalone companion usable through a separate
+ * profile row.
+ * @module dsh-doublecheck/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { TestRunDetection } from './domain/evidence.ts';
+/** Full npm package name owning the reported failures. */
+export declare const PACKAGE_NAME = "dsh-doublecheck";
+/** A package-attributed invariant failure reported by the host registry. */
+export type InvariantFailure = (message: string) => never;
+/** Facts the installer needs beyond the event stream. */
+export interface InvariantFacts {
+    /** The compiled red/green detection backing the report re-derivation. */
+    detection(): TestRunDetection;
+}
+/** Installer callback accepted by the host's invariant registry. */
+export type InvariantInstaller = (ctx: Context, fail: InvariantFailure) => void | Promise<void>;
+/** Minimal runtime contract used by the companion without a source checkout. */
+export interface InvariantRegistry {
+    register(packageName: string, installer: InvariantInstaller): () => void;
+}
+/** Cordis companion plugin name. */
+export declare const name = "dsh-doublecheck-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Build the installer over a facts source. The standalone companion and the
+ * main plugin share this body; only the facts differ.
+ * @param facts - the report re-derivation knobs.
+ * @returns the installer the host registry activates in its child context.
+ */
+export declare function installInvariant(facts: InvariantFacts): InvariantInstaller;
+/**
+ * Register the standalone companion with envelope-only facts.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;

package/lib/invariant.js

@@ -0,0 +1,112 @@
+/**
+ * Package-owned invariant companion for dsh-doublecheck.
+ *
+ * Three post-commit diagnostic checks over the events this package's write
+ * paths produce (all three target events are committed before dispatch, so a
+ * violation is reported — via the host registry's `fail` — rather than
+ * vetoed):
+ *
+ * 1. Every `doublecheck/spec` announcement carries six non-empty spec fields.
+ * 2. Every `doublecheck/report` announcement's verdict is consistent with the
+ *    log re-derivation. When verification did not run, the two must be equal;
+ *    when verification ran, a failing check must report `challenged` and a
+ *    clean one must report `proven` or `unverified` (the `complete` fact rides
+ *    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).
+ *
+ * The guard registers a facts-bearing installer from its own context; the
+ * `./invariant` export is the standalone companion usable through a separate
+ * profile row.
+ * @module dsh-doublecheck/invariant
+ */
+import { deriveReportVerdict, foldReportFacts } from "./domain/report.js";
+/** Full npm package name owning the reported failures. */
+export const PACKAGE_NAME = 'dsh-doublecheck';
+/** Cordis companion plugin name. */
+export const name = 'dsh-doublecheck-invariant';
+/** Service required before the companion can reserve package ownership. */
+export const inject = ['invariants'];
+/** All six spec fields, in declaration order. */
+const SPEC_FIELDS = [
+    'goal', 'scope', 'acceptanceCriteria', 'failureModes', 'priorities', 'nonGoals',
+];
+/**
+ * Build the installer over a facts source. The standalone companion and the
+ * main plugin share this body; only the facts differ.
+ * @param facts - the report re-derivation knobs.
+ * @returns the installer the host registry activates in its child context.
+ */
+export function installInvariant(facts) {
+    return (ctx, fail) => {
+        ctx.on('doublecheck/spec', (payload) => {
+            for (const field of SPEC_FIELDS) {
+                if (typeof payload.spec[field] !== 'string' || payload.spec[field].trim() === '') {
+                    fail(`doublecheck/spec announcement carries an empty "${field}" field`);
+                }
+            }
+        });
+        ctx.on('doublecheck/report', (payload) => {
+            const folded = foldReportFacts(payload.session.events, facts.detection());
+            if (payload.verification === null) {
+                const rederived = deriveReportVerdict(folded, null);
+                if (rederived !== payload.verdict) {
+                    fail(`doublecheck/report announces verdict "${payload.verdict}" but the log re-derives "${rederived}"`);
+                }
+                return;
+            }
+            const hasFailure = payload.verification.checks.some(check => check.verdict === 'fail');
+            if (hasFailure && payload.verdict !== 'challenged') {
+                fail(`doublecheck/report carries a failing verification check but announces verdict "${payload.verdict}"`);
+            }
+            if (!hasFailure && payload.verdict !== 'proven' && payload.verdict !== 'unverified') {
+                fail(`doublecheck/report carries clean verification checks but announces verdict "${payload.verdict}"`);
+            }
+        });
+        ctx.on('doublecheck/review', (payload) => {
+            const verdicts = ['findings', 'clean', 'unavailable'];
+            if (!verdicts.includes(payload.verdict)) {
+                fail(`doublecheck/review announces invalid verdict ${JSON.stringify(payload.verdict)}`);
+            }
+            for (const finding of payload.findings) {
+                const severities = ['blocker', 'major', 'minor', 'info'];
+                if (!severities.includes(finding.severity)) {
+                    fail(`doublecheck/review finding has invalid severity ${JSON.stringify(finding.severity)}`);
+                }
+                if (typeof finding.title !== 'string' || finding.title.trim() === '') {
+                    fail('doublecheck/review finding has an empty title');
+                }
+                if (typeof finding.detail !== 'string' || finding.detail.trim() === '') {
+                    fail('doublecheck/review finding has an empty detail');
+                }
+            }
+        });
+    };
+}
+/**
+ * Resolve the host registry through Cordis's named service lookup. Keeping
+ * this narrow local contract lets the companion build without host source
+ * files; a composed DSH profile still supplies the real `invariants` service.
+ * @param ctx - Cordis context carrying the host service.
+ * @returns the host invariant registry.
+ * @throws {Error} when the companion is loaded without its host service.
+ */
+function getInvariantRegistry(ctx) {
+    const registry = ctx.get('invariants');
+    if (registry === undefined) {
+        throw new Error(`invariant companion requires the "invariants" service for ${PACKAGE_NAME}`);
+    }
+    return registry;
+}
+/** Facts for the standalone companion: the report check degrades to no test-run evidence. */
+const COMPANION_FACTS = {
+    detection: () => ({
+        testToolNames: [], testCommandPatterns: [], mutationTools: [], testFilePatterns: [],
+    }),
+};
+/**
+ * Register the standalone companion with envelope-only facts.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export const apply = (ctx) => Promise.resolve(getInvariantRegistry(ctx).register(PACKAGE_NAME, installInvariant(COMPANION_FACTS)));

package/lib/types.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Durable type-table merges owned by this package.
+ *
+ * The `doublecheck` projection key is declared here (its one home) and
+ * re-exported from the package root so consumers receive the
+ * `SessionProjectionMap` merge.
+ * @module dsh-doublecheck/types
+ */
+import { z as zod } from 'zod';
+import type { DisciplineStage, TestColor } from './domain/stages.ts';
+/** The whole wire value of the `doublecheck` session projection. */
+export interface DoublecheckView {
+    /** The last discipline stage reached on durable evidence. */
+    stage: DisciplineStage;
+    /** The latest test-run evidence color. */
+    color: TestColor;
+    /** Whether a committed requirements spec exists in the log. */
+    hasSpec: boolean;
+    /** The goal of the latest committed spec, or '' before any spec. */
+    specGoal: string;
+    /** Whether an adversary review record exists in the log. */
+    reviewed: boolean;
+    /** Total implementation edits folded so far. */
+    editCount: number;
+}
+/** Validates the `doublecheck` projection's wire payload before it leaves the host. */
+export declare const doublecheckViewSchema: zod.ZodObject<{
+    stage: zod.ZodUnion<readonly [zod.ZodLiteral<"grill">, zod.ZodLiteral<"design">, zod.ZodLiteral<"red">, zod.ZodLiteral<"green">, zod.ZodLiteral<"review">, zod.ZodLiteral<"verify">]>;
+    color: zod.ZodUnion<readonly [zod.ZodLiteral<"none">, zod.ZodLiteral<"red">, zod.ZodLiteral<"green">]>;
+    hasSpec: zod.ZodBoolean;
+    specGoal: zod.ZodString;
+    reviewed: zod.ZodBoolean;
+    editCount: zod.ZodNumber;
+}, zod.core.$strip>;
+declare module '@deepseek-ai/dsh-session-projection/types' {
+    interface SessionProjectionMap {
+        doublecheck: DoublecheckView;
+    }
+}

package/lib/types.js

@@ -0,0 +1,18 @@
+/**
+ * Durable type-table merges owned by this package.
+ *
+ * The `doublecheck` projection key is declared here (its one home) and
+ * re-exported from the package root so consumers receive the
+ * `SessionProjectionMap` merge.
+ * @module dsh-doublecheck/types
+ */
+import { z as zod } from 'zod';
+/** Validates the `doublecheck` projection's wire payload before it leaves the host. */
+export const doublecheckViewSchema = zod.object({
+    stage: zod.union([zod.literal('grill'), zod.literal('design'), zod.literal('red'), zod.literal('green'), zod.literal('review'), zod.literal('verify')]),
+    color: zod.union([zod.literal('none'), zod.literal('red'), zod.literal('green')]),
+    hasSpec: zod.boolean(),
+    specGoal: zod.string(),
+    reviewed: zod.boolean(),
+    editCount: zod.number(),
+});

package/package.json

@@ -0,0 +1,109 @@
+{
+  "name": "dsh-doublecheck",
+  "version": "0.5.0",
+  "description": "Double-check before you ship: grill the requirements, test the implementation, prove the delivery.",
+  "packageManager": "pnpm@11.7.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/PerryLink/dsh-doublecheck.git"
+  },
+  "homepage": "https://github.com/PerryLink/dsh-doublecheck#readme",
+  "bugs": {
+    "url": "https://github.com/PerryLink/dsh-doublecheck/issues"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js"
+    },
+    "./grill": {
+      "types": "./lib/grill/index.d.ts",
+      "import": "./lib/grill/index.js"
+    },
+    "./guard": {
+      "types": "./lib/guard/index.d.ts",
+      "import": "./lib/guard/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "skills",
+    "cordis.patch.yml",
+    "CHANGELOG.md",
+    "README.md",
+    "README.zh.md",
+    "README.es.md",
+    "README.pt.md",
+    "README.hi.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc --noEmitOnError",
+    "prepare": "tsc --noEmitOnError",
+    "prepublishOnly": "tsc --noEmitOnError && pnpm run test",
+    "typecheck": "tsc --noEmit && tsc -p tsconfig.tests.json",
+    "lint": "eslint src tests",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "pack:check": "pnpm run build && pnpm pack"
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "engineering-discipline",
+    "requirements",
+    "guard",
+    "skill"
+  ],
+  "author": "PerryLink",
+  "license": "Apache-2.0",
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-agent": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-commands": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-llm": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-session": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-session-projection": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-skill": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-tools": "0.1.0-rc.6",
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "dependencies": {
+    "typescript": "^5.7.0"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-agent": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-commands": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-fs": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-llm": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-session": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-session-projection": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-skill": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-subagent": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-system-prompt": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-tools": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-workflow": "0.1.0-rc.6",
+    "@deepseek-ai/schemastery": "^3.18.1",
+    "@eslint/js": "^9.30.0",
+    "@types/node": "^22.15.0",
+    "@vitest/coverage-v8": "^3.2.0",
+    "eslint": "^9.30.0",
+    "typescript-eslint": "^8.35.0",
+    "vitest": "^3.2.0",
+    "zod": "^4.4.3"
+  }
+}