codex-plugin-doctor 1.0.2 → 1.1.0

package/README.md

@@ -282,7 +282,7 @@ codex-plugin-doctor check . --json --runtime --verbose-runtime
 
 `self-test` runs the bundled runtime-complete sample through static validation, runtime MCP probes, and the compatibility scorecard. It is the fastest post-install check after `npm install -g codex-plugin-doctor`.
 
-`doctor` checks the local environment, including package version, platform, Node version, npm global prefix, Codex home, and Codex plugin cache visibility. The text output also includes recommended next commands for self-test, installed plugin discovery, runtime checks, compatibility scoring, and CI setup. `doctor contract` publishes the machine-readable output contract, including public JSON schema surfaces, stable-through-1.0 compatibility metadata, and a frozen rule catalog digest. Add `--json` for automation or `--output output-contract.json` to write the contract to disk. `doctor corpus` runs the bundled validation corpus against healthy runtime, risky security, starter skill, and generic MCP packages, then reports whether each case matched its expected outcome. Add `--json` for automation or `--output validation-corpus.json` to write the corpus report to disk. `doctor npm <package>` runs a preinstall scan by packing the npm package with scripts disabled, extracting the publish tarball, and running validation, security, trust, and recommendation checks against the shipped contents. Use a published Codex plugin package as the target; scanning `codex-plugin-doctor` itself intentionally reports a missing plugin manifest because this CLI package is not a plugin package. Add `--json` for automation or `--output npm-preinstall.json` to write the report to disk. `doctor attest <path>` creates a local attestation with stable package/report digests, validation/security/compatibility/trust summary, and verification metadata. Add `--sign-key-env NAME` to attach a local HMAC-SHA256 signature without printing the secret, or `--json --output attestation.json` to write the artifact to disk. `doctor attest verify <attestation.json> --target <path> --sign-key-env NAME` recomputes the package fingerprint, report digest, and HMAC signature offline; verification intentionally treats `generatedAt`, `targetPath`, `verification`, and `signature.keyHint` as unsigned display metadata. `doctor inspector <path>` builds a safe MCP Inspector launch command from a packaged `.mcp.json` file without starting the Inspector proxy automatically. Use `--server <name>` when the package contains multiple MCP server entries. `doctor diff --before <path> --after <path>` compares two package roots and reports new findings, resolved findings, trust score delta, and whether risk increased. `doctor recommend <path>` turns validation, security, and compatibility signals into a prioritized action plan with blocker, high, medium, and info actions. Add `--json` for automation or `--output recommendations.json` to write the report to disk. `doctor trust <path>` creates a local trust score from package lifecycle scripts, dependency specs, and MCP security findings. Use it before release when you want supply-chain risks summarized as one score. `doctor perf <path>` profiles the shared package analysis pipeline and reports per-stage durations for validation, config, security, compatibility, trust, recommendations, and total runtime. Add `--max-total-ms <ms>` or repeatable `--max-stage-ms stage=ms` to fail CI when a budget is exceeded. `doctor mcp <path>` exposes the generic MCP static health report under the doctor command family without starting local MCP servers. `doctor export --bundle <path>` creates a redacted operator handoff bundle that includes validation JSON, security scorecard data, compatibility matrix, recommendations, and trust score in one file. `doctor snapshot` creates a redacted diagnostics bundle with environment health, client config readiness, installed plugin metadata, and next commands. Add `--json` for machine-readable output or `--output doctor-snapshot.json` to write the bundle to disk. `doctor clients` reports local Codex, Claude Desktop, Cursor, Cline, and Windsurf config readiness. `doctor --update-check` compares the installed CLI version with the latest npm version and prints the upgrade command when a newer release is available.
+`doctor` checks the local environment, including package version, platform, Node version, npm global prefix, Codex home, and Codex plugin cache visibility. The text output also includes recommended next commands for self-test, installed plugin discovery, runtime checks, compatibility scoring, and CI setup. `doctor contract` publishes the machine-readable output contract, including public JSON schema surfaces, stable-through-1.0 compatibility metadata, and a frozen rule catalog digest. Add `--json` for automation or `--output output-contract.json` to write the contract to disk. `doctor corpus` runs the bundled validation corpus against healthy runtime, risky security, starter skill, and generic MCP packages, then reports whether each case matched its expected outcome. Add `--json` for automation or `--output validation-corpus.json` to write the corpus report to disk. `doctor npm <package>` runs a preinstall scan by packing the npm package with scripts disabled, extracting the publish tarball, and running validation, security, trust, and recommendation checks against the shipped contents. Use a published Codex plugin package as the target; scanning `codex-plugin-doctor` itself intentionally reports a missing plugin manifest because this CLI package is not a plugin package. Add `--json` for automation or `--output npm-preinstall.json` to write the report to disk. `doctor attest <path>` creates a local attestation with stable package/report digests, validation/security/compatibility/trust summary, and verification metadata. Add `--sign-key-env NAME` to attach a local HMAC-SHA256 signature without printing the secret, or `--json --output attestation.json` to write the artifact to disk. `doctor attest verify <attestation.json> --target <path> --sign-key-env NAME` recomputes the package fingerprint, report digest, and HMAC signature offline; verification intentionally treats `generatedAt`, `targetPath`, `verification`, and `signature.keyHint` as unsigned display metadata. `doctor release-evidence <path> --sign-key-env NAME` creates one redacted release bundle with signed attestation, offline verification, corpus, performance, security, trust, package metadata, and git release gates. Strict release evidence requires a clean tagged worktree; use `--allow-dirty` or `--allow-untagged` only for local rehearsal. `doctor release-evidence verify <evidence.json> --target <path> --sign-key-env NAME` verifies a shared release evidence artifact offline against an explicit package path; the artifact target path is treated as display metadata, not trusted input. `doctor release-evidence asset <path> --tag <tag> --output <evidence.json> --sign-key-env NAME` writes a signed release evidence file and prints the `gh release upload` command; add `--upload` to run the upload through GitHub CLI with `--clobber`. `doctor inspector <path>` builds a safe MCP Inspector launch command from a packaged `.mcp.json` file without starting the Inspector proxy automatically. Use `--server <name>` when the package contains multiple MCP server entries. `doctor diff --before <path> --after <path>` compares two package roots and reports new findings, resolved findings, trust score delta, and whether risk increased. `doctor recommend <path>` turns validation, security, and compatibility signals into a prioritized action plan with blocker, high, medium, and info actions. Add `--json` for automation or `--output recommendations.json` to write the report to disk. `doctor trust <path>` creates a local trust score from package lifecycle scripts, dependency specs, and MCP security findings. Use it before release when you want supply-chain risks summarized as one score. `doctor perf <path>` profiles the shared package analysis pipeline and reports per-stage durations for validation, config, security, compatibility, trust, recommendations, and total runtime. Add `--max-total-ms <ms>` or repeatable `--max-stage-ms stage=ms` to fail CI when a budget is exceeded. `doctor mcp <path>` exposes the generic MCP static health report under the doctor command family without starting local MCP servers. `doctor export --bundle <path>` creates a redacted operator handoff bundle that includes validation JSON, security scorecard data, compatibility matrix, recommendations, and trust score in one file. `doctor snapshot` creates a redacted diagnostics bundle with environment health, client config readiness, installed plugin metadata, and next commands. Add `--json` for machine-readable output or `--output doctor-snapshot.json` to write the bundle to disk. `doctor clients` reports local Codex, Claude Desktop, Cursor, Cline, and Windsurf config readiness. `doctor --update-check` compares the installed CLI version with the latest npm version and prints the upgrade command when a newer release is available.
 
 `audit --installed` runs a local ecosystem audit against every discovered Codex plugin in the installed plugin cache. Add `--security` to include security scorecards, `--compat` to include the all-client compatibility matrix, and `--json --output local-audit.json` when you want a shareable machine-readable report. Add `--cache` to reuse unchanged plugin results between runs; add `--changed` to only report plugins whose fingerprint changed since the last cached audit. Use `--cache-file path/to/audit-cache.json` when CI or scripted runs need an explicit cache location.
 
@@ -348,9 +348,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v5
-      - uses: Esquetta/CodexPluginDoctor@v1.0.2
+      - uses: Esquetta/CodexPluginDoctor@v1.1.0
         with:
-          version: "1.0.2"
+          version: "1.1.0"
           path: .
           runtime: "true"
           policy: codex-publish

package/dist/core/attestation.d.ts

@@ -93,9 +93,11 @@ export interface DoctorAttestationVerificationCheck {
 }
 export interface VerifyDoctorAttestationOptions {
     signingKey: string;
+    artifactPath?: string;
 }
 export declare function buildDoctorAttestation(targetPath: string, options?: BuildDoctorAttestationOptions): Promise<DoctorAttestation>;
 export declare function verifyDoctorAttestation(artifactPath: string, targetPath: string, options: VerifyDoctorAttestationOptions): Promise<DoctorAttestationVerificationReport>;
+export declare function verifyDoctorAttestationObject(artifact: unknown, targetPath: string, options: VerifyDoctorAttestationOptions): Promise<DoctorAttestationVerificationReport>;
 export declare function renderDoctorAttestationJson(attestation: DoctorAttestation): string;
 export declare function renderDoctorAttestationVerificationJson(report: DoctorAttestationVerificationReport): string;
 export declare function renderDoctorAttestationVerification(report: DoctorAttestationVerificationReport, options?: {

package/dist/core/attestation.js

@@ -298,12 +298,19 @@ function createDigestVerificationCheck(id, message, expected, actual, includeDig
 export async function verifyDoctorAttestation(artifactPath, targetPath, options) {
     const resolvedArtifactPath = path.resolve(artifactPath);
     const artifact = await readJsonFile(resolvedArtifactPath);
+    return verifyDoctorAttestationObject(artifact, targetPath, {
+        ...options,
+        artifactPath: resolvedArtifactPath
+    });
+}
+export async function verifyDoctorAttestationObject(artifact, targetPath, options) {
+    const artifactPath = options.artifactPath ?? "inline:doctor.attestation";
     if (!isDoctorAttestation(artifact)) {
         return {
             schemaVersion: "1.0.0",
             kind: "doctor.attestation.verification",
             generatedAt: new Date().toISOString(),
-            artifactPath: resolvedArtifactPath,
+            artifactPath,
             targetPath: path.resolve(targetPath),
             status: "fail",
             exitCode: 1,
@@ -359,7 +366,7 @@ export async function verifyDoctorAttestation(artifactPath, targetPath, options)
         schemaVersion: "1.0.0",
         kind: "doctor.attestation.verification",
         generatedAt: new Date().toISOString(),
-        artifactPath: resolvedArtifactPath,
+        artifactPath,
         targetPath: expected.targetPath,
         status: failedChecks.length === 0 ? "pass" : "fail",
         exitCode: failedChecks.length === 0 ? 0 : 1,

package/dist/core/doctor-export-bundle.d.ts

@@ -15,6 +15,8 @@ export interface DoctorExportBundle {
     recommendations: DoctorRecommendationsReport;
     trust: TrustScoreReport;
 }
+export declare function redactString(value: string): string;
+export declare function redactValue(value: unknown): unknown;
 export declare function buildDoctorExportBundle(targetPath: string, environment?: CompatibilityEnvironment): Promise<DoctorExportBundle>;
 export declare function renderDoctorExportBundleJson(bundle: DoctorExportBundle): string;
 export declare function renderDoctorExportBundle(bundle: DoctorExportBundle, options?: {

package/dist/core/doctor-export-bundle.js

@@ -1,12 +1,12 @@
 import { buildDoctorExportBundleFromAnalysis, buildDoctorRecommendationsFromAnalysis, buildPackageAnalysis } from "./package-analysis.js";
-function redactString(value) {
+export function redactString(value) {
     return value
         .replace(/sk-[A-Za-z0-9_-]{12,}/g, "[REDACTED_SECRET]")
         .replace(/npm_[A-Za-z0-9_-]{12,}/g, "[REDACTED_SECRET]")
         .replace(/gh[pousr]_[A-Za-z0-9_]{12,}/g, "[REDACTED_SECRET]")
         .replace(/SHOULD_NOT_LEAK/g, "[REDACTED_SECRET]");
 }
-function redactValue(value) {
+export function redactValue(value) {
     if (typeof value === "string") {
         return redactString(value);
     }

package/dist/core/output-contract.js

@@ -89,6 +89,24 @@ const publicSchemaDefinitions = [
         outputKind: "doctor.attestation.verification",
         required: ["schemaVersion", "kind", "generatedAt", "artifactPath", "targetPath", "status", "exitCode", "summary", "unsignedFields", "checks"]
     },
+    {
+        id: "doctor.release.evidence.json",
+        command: "codex-plugin-doctor doctor release-evidence <path> --json",
+        outputKind: "doctor.release.evidence",
+        required: ["schemaVersion", "kind", "generatedAt", "version", "targetPath", "status", "exitCode", "releaseReady", "summary", "package", "git", "releaseGates", "attestation", "attestationVerification", "corpus", "performance", "security", "trust", "evidenceSignature"]
+    },
+    {
+        id: "doctor.release.evidence.verification.json",
+        command: "codex-plugin-doctor doctor release-evidence verify <evidence.json> --target <path> --json",
+        outputKind: "doctor.release.evidence.verification",
+        required: ["schemaVersion", "kind", "generatedAt", "artifactPath", "targetPath", "status", "exitCode", "summary", "checks", "attestation"]
+    },
+    {
+        id: "doctor.release.evidence.asset.json",
+        command: "codex-plugin-doctor doctor release-evidence asset <path> --tag <tag> --output <evidence.json> --json",
+        outputKind: "doctor.release.evidence.asset",
+        required: ["schemaVersion", "kind", "generatedAt", "version", "targetPath", "tag", "artifactPath", "status", "exitCode", "uploaded", "uploadCommand", "releaseEvidence"]
+    },
     {
         id: "doctor.npm.json",
         command: "codex-plugin-doctor doctor npm <package> --json",

package/dist/core/release-evidence.d.ts

@@ -0,0 +1,129 @@
+import { type DoctorAttestation, type DoctorAttestationVerificationReport } from "./attestation.js";
+import { type DoctorPerformanceReport, type DoctorPerformanceThresholdOptions } from "./performance-report.js";
+import { type DoctorValidationCorpusReport } from "./validation-corpus.js";
+import { type SecurityAudit } from "../security/security-audit.js";
+import { type TrustScoreReport } from "../security/trust-score.js";
+import type { CompatibilityEnvironment } from "../compatibility/compatibility-matrix.js";
+import type { CheckResult } from "../domain/types.js";
+type EvidenceStatus = "pass" | "warn" | "fail";
+export interface DoctorReleaseEvidenceSignature {
+    status: "signed";
+    algorithm: "hmac-sha256";
+    digest: string;
+    payloadDigest: string;
+    keyHint: string;
+}
+export interface DoctorReleaseEvidencePackageMetadata {
+    name: string | null;
+    version: string | null;
+    private: boolean | null;
+}
+export interface DoctorReleaseEvidenceGitMetadata {
+    commit: string | null;
+    tag: string | null;
+    dirty: boolean | null;
+}
+export interface DoctorReleaseEvidenceReport {
+    schemaVersion: "1.0.0";
+    kind: "doctor.release.evidence";
+    generatedAt: string;
+    version: string;
+    targetPath: string;
+    status: "pass" | "fail";
+    exitCode: 0 | 1;
+    releaseReady: boolean;
+    summary: {
+        attestation: EvidenceStatus;
+        attestationVerification: EvidenceStatus;
+        corpus: EvidenceStatus;
+        performance: EvidenceStatus;
+        releaseGates: EvidenceStatus;
+        security: EvidenceStatus;
+        trust: EvidenceStatus;
+    };
+    releaseGates: {
+        status: EvidenceStatus;
+        checks: Array<{
+            id: string;
+            status: EvidenceStatus;
+            message: string;
+        }>;
+    };
+    package: DoctorReleaseEvidencePackageMetadata;
+    git: DoctorReleaseEvidenceGitMetadata;
+    attestation: DoctorAttestation;
+    attestationVerification: DoctorAttestationVerificationReport;
+    corpus: DoctorValidationCorpusReport;
+    performance: DoctorPerformanceReport;
+    security: Pick<SecurityAudit, "status" | "score" | "findingCounts">;
+    trust: Pick<TrustScoreReport, "status" | "score" | "findingCounts">;
+    evidenceSignature: DoctorReleaseEvidenceSignature;
+}
+export interface DoctorReleaseEvidenceVerificationReport {
+    schemaVersion: "1.0.0";
+    kind: "doctor.release.evidence.verification";
+    generatedAt: string;
+    artifactPath: string;
+    targetPath: string | null;
+    status: "pass" | "fail";
+    exitCode: 0 | 1;
+    summary: {
+        artifact: EvidenceStatus;
+        attestation: EvidenceStatus;
+        evidenceSignature: EvidenceStatus;
+        releaseReady: EvidenceStatus;
+        releaseGates: EvidenceStatus;
+    };
+    checks: Array<{
+        id: string;
+        status: EvidenceStatus;
+        message: string;
+    }>;
+    attestation: DoctorAttestationVerificationReport | null;
+}
+export interface DoctorReleaseEvidenceAssetReport {
+    schemaVersion: "1.0.0";
+    kind: "doctor.release.evidence.asset";
+    generatedAt: string;
+    version: string;
+    targetPath: string;
+    tag: string;
+    artifactPath: string;
+    status: "pass" | "fail";
+    exitCode: 0 | 1;
+    uploaded: boolean;
+    uploadCommand: string[];
+    releaseEvidence: {
+        status: "pass" | "fail";
+        releaseReady: boolean;
+        evidenceSignature: "signed";
+    };
+}
+export interface BuildDoctorReleaseEvidenceOptions {
+    signingKey: string;
+    signingKeyEnv: string;
+    allowDirty?: boolean;
+    allowUntagged?: boolean;
+    environment?: CompatibilityEnvironment;
+    runCheck?: (targetPath: string) => Promise<CheckResult>;
+    performanceThresholds?: DoctorPerformanceThresholdOptions;
+}
+export declare function buildDoctorReleaseEvidenceReport(targetPath: string, options: BuildDoctorReleaseEvidenceOptions): Promise<DoctorReleaseEvidenceReport>;
+export declare function renderDoctorReleaseEvidenceJson(report: DoctorReleaseEvidenceReport): string;
+export declare function verifyDoctorReleaseEvidence(artifactPath: string, options: {
+    signingKey: string;
+    targetPath: string;
+}): Promise<DoctorReleaseEvidenceVerificationReport>;
+export declare function renderDoctorReleaseEvidenceVerificationJson(report: DoctorReleaseEvidenceVerificationReport): string;
+export declare function renderDoctorReleaseEvidenceVerification(report: DoctorReleaseEvidenceVerificationReport, options?: {
+    outputPath?: string | null;
+}): string;
+export declare function buildDoctorReleaseEvidenceAssetReport(evidence: DoctorReleaseEvidenceReport, options: {
+    tag: string;
+    artifactPath: string;
+    uploaded: boolean;
+}): DoctorReleaseEvidenceAssetReport;
+export declare function renderDoctorReleaseEvidenceAssetJson(report: DoctorReleaseEvidenceAssetReport): string;
+export declare function renderDoctorReleaseEvidenceAsset(report: DoctorReleaseEvidenceAssetReport): string;
+export declare function renderDoctorReleaseEvidence(report: DoctorReleaseEvidenceReport): string;
+export {};

package/dist/core/release-evidence.js

@@ -0,0 +1,455 @@
+import { execFile } from "node:child_process";
+import { createHash, createHmac, timingSafeEqual } from "node:crypto";
+import { promisify } from "node:util";
+import path from "node:path";
+import { buildDoctorAttestation, verifyDoctorAttestationObject } from "./attestation.js";
+import { buildDoctorPerformanceReport } from "./performance-report.js";
+import { buildDoctorValidationCorpusReport } from "./validation-corpus.js";
+import { redactValue } from "./doctor-export-bundle.js";
+import { readJsonFile } from "./read-json-file.js";
+import { buildSecurityAudit } from "../security/security-audit.js";
+import { buildTrustScore } from "../security/trust-score.js";
+import { packageVersion } from "../version.js";
+const execFileAsync = promisify(execFile);
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stableStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+    }
+    if (isPlainObject(value)) {
+        return `{${Object.keys(value)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function sha256(value) {
+    return `sha256:${createHash("sha256").update(value).digest("hex")}`;
+}
+function digestMatches(expected, actual) {
+    const expectedBuffer = Buffer.from(expected);
+    const actualBuffer = Buffer.from(actual);
+    return expectedBuffer.length === actualBuffer.length &&
+        timingSafeEqual(expectedBuffer, actualBuffer);
+}
+function isDoctorReleaseEvidenceReport(value) {
+    return isPlainObject(value) &&
+        value.schemaVersion === "1.0.0" &&
+        value.kind === "doctor.release.evidence" &&
+        typeof value.targetPath === "string" &&
+        isPlainObject(value.summary) &&
+        isPlainObject(value.releaseGates) &&
+        isPlainObject(value.attestation) &&
+        isPlainObject(value.evidenceSignature);
+}
+function toEvidenceStatus(status) {
+    return status;
+}
+async function readPackageMetadata(rootPath) {
+    try {
+        const packageJson = await readJsonFile(path.join(rootPath, "package.json"));
+        return {
+            name: typeof packageJson.name === "string" ? packageJson.name : null,
+            version: typeof packageJson.version === "string" ? packageJson.version : null,
+            private: typeof packageJson.private === "boolean" ? packageJson.private : null
+        };
+    }
+    catch {
+        return {
+            name: null,
+            version: null,
+            private: null
+        };
+    }
+}
+async function readGitValue(args, cwd) {
+    try {
+        const { stdout } = await execFileAsync("git", args, { cwd });
+        const value = stdout.trim();
+        return value.length > 0 ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function readGitDirty(cwd) {
+    try {
+        const { stdout } = await execFileAsync("git", ["status", "--short"], { cwd });
+        return stdout.trim().length > 0;
+    }
+    catch {
+        return null;
+    }
+}
+async function readGitMetadata(rootPath) {
+    const [commit, tag, dirtyOutput] = await Promise.all([
+        readGitValue(["rev-parse", "HEAD"], rootPath),
+        readGitValue(["describe", "--tags", "--exact-match"], rootPath),
+        readGitDirty(rootPath)
+    ]);
+    return {
+        commit,
+        tag,
+        dirty: dirtyOutput
+    };
+}
+function releaseReady(report) {
+    return report.attestation.summary.status !== "fail" &&
+        report.attestationVerification.status === "pass" &&
+        report.corpus.summary.status === "pass" &&
+        report.performance.status === "pass" &&
+        report.releaseGates.status === "pass" &&
+        report.security.status !== "fail" &&
+        report.trust.status !== "fail";
+}
+function buildReleaseGateReport(git, options) {
+    const checks = [
+        {
+            id: "git.commit.present",
+            status: git.commit ? "pass" : "fail",
+            message: git.commit
+                ? "Git commit resolved for this release evidence bundle."
+                : "Git commit could not be resolved."
+        },
+        {
+            id: "git.tag.exact",
+            status: git.tag || options.allowUntagged ? "pass" : "fail",
+            message: git.tag
+                ? `Current commit is tagged as ${git.tag}.`
+                : options.allowUntagged
+                    ? "Current commit is not on an exact git tag, but --allow-untagged was explicitly set."
+                    : "Current commit is not on an exact git tag."
+        },
+        {
+            id: "git.worktree.clean",
+            status: git.dirty === false || options.allowDirty ? "pass" : "fail",
+            message: git.dirty === false
+                ? "Git worktree is clean."
+                : options.allowDirty
+                    ? "Git worktree is dirty, but --allow-dirty was explicitly set."
+                    : "Git worktree has uncommitted changes."
+        }
+    ];
+    return {
+        status: checks.every((check) => check.status === "pass") ? "pass" : "fail",
+        checks
+    };
+}
+function buildReleaseEvidenceSigningPayload(report) {
+    return {
+        schemaVersion: report.schemaVersion,
+        kind: "doctor.release.evidence.signature.v1",
+        version: report.version,
+        status: report.status,
+        releaseReady: report.releaseReady,
+        summary: report.summary,
+        package: report.package,
+        git: report.git,
+        releaseGates: report.releaseGates,
+        attestation: {
+            version: report.attestation.version,
+            subject: report.attestation.subject,
+            packageFingerprint: report.attestation.packageFingerprint,
+            reportDigest: report.attestation.reportDigest,
+            summary: report.attestation.summary,
+            signature: report.attestation.signature
+        },
+        attestationVerification: {
+            status: report.attestationVerification.status,
+            summary: report.attestationVerification.summary
+        },
+        corpus: {
+            status: report.corpus.summary.status,
+            summary: report.corpus.summary
+        },
+        performance: {
+            status: report.performance.status,
+            summary: report.performance.summary,
+            thresholds: report.performance.thresholds
+        },
+        security: report.security,
+        trust: report.trust
+    };
+}
+function signReleaseEvidence(report, signingKey, keyHint) {
+    const redactedReport = redactValue(report);
+    const serializedPayload = stableStringify(buildReleaseEvidenceSigningPayload(redactedReport));
+    return {
+        status: "signed",
+        algorithm: "hmac-sha256",
+        digest: `sha256:${createHmac("sha256", signingKey)
+            .update(serializedPayload)
+            .digest("hex")}`,
+        payloadDigest: sha256(serializedPayload),
+        keyHint
+    };
+}
+export async function buildDoctorReleaseEvidenceReport(targetPath, options) {
+    const rootPath = path.resolve(targetPath);
+    const security = await buildSecurityAudit(rootPath);
+    const [attestation, corpus, performance, trust, packageMetadata, git] = await Promise.all([
+        buildDoctorAttestation(rootPath, {
+            signingKey: options.signingKey,
+            signingKeyHint: `env:${options.signingKeyEnv}`,
+            recomputeKeyEnv: options.signingKeyEnv
+        }),
+        buildDoctorValidationCorpusReport({ environment: options.environment }),
+        buildDoctorPerformanceReport(rootPath, {
+            environment: options.environment,
+            runCheck: options.runCheck,
+            thresholds: options.performanceThresholds
+        }),
+        buildTrustScore(rootPath, { securityAudit: security }),
+        readPackageMetadata(rootPath),
+        readGitMetadata(rootPath)
+    ]);
+    const normalizedPackageMetadata = {
+        name: packageMetadata.name ?? attestation.subject.name,
+        version: packageMetadata.version ?? attestation.subject.version,
+        private: packageMetadata.private
+    };
+    const attestationVerification = await verifyDoctorAttestationObject(attestation, rootPath, {
+        signingKey: options.signingKey,
+        artifactPath: "inline:doctor.release-evidence.attestation"
+    });
+    const releaseGates = buildReleaseGateReport(git, options);
+    const partialReport = {
+        schemaVersion: "1.0.0",
+        kind: "doctor.release.evidence",
+        generatedAt: new Date().toISOString(),
+        version: packageVersion,
+        targetPath: rootPath,
+        summary: {
+            attestation: toEvidenceStatus(attestation.summary.status),
+            attestationVerification: attestationVerification.status,
+            corpus: corpus.summary.status,
+            performance: performance.status,
+            releaseGates: releaseGates.status,
+            security: toEvidenceStatus(security.status),
+            trust: toEvidenceStatus(trust.status)
+        },
+        package: normalizedPackageMetadata,
+        git,
+        releaseGates,
+        attestation,
+        attestationVerification,
+        corpus,
+        performance,
+        security: {
+            status: security.status,
+            score: security.score,
+            findingCounts: security.findingCounts
+        },
+        trust: {
+            status: trust.status,
+            score: trust.score,
+            findingCounts: trust.findingCounts
+        }
+    };
+    const ready = releaseReady(partialReport);
+    const report = {
+        ...partialReport,
+        status: (ready ? "pass" : "fail"),
+        exitCode: (ready ? 0 : 1),
+        releaseReady: ready
+    };
+    return {
+        ...report,
+        evidenceSignature: signReleaseEvidence(report, options.signingKey, `env:${options.signingKeyEnv}`)
+    };
+}
+export function renderDoctorReleaseEvidenceJson(report) {
+    return JSON.stringify(redactValue(report), null, 2);
+}
+export async function verifyDoctorReleaseEvidence(artifactPath, options) {
+    const resolvedArtifactPath = path.resolve(artifactPath);
+    const artifact = await readJsonFile(resolvedArtifactPath);
+    if (!isDoctorReleaseEvidenceReport(artifact)) {
+        return {
+            schemaVersion: "1.0.0",
+            kind: "doctor.release.evidence.verification",
+            generatedAt: new Date().toISOString(),
+            artifactPath: resolvedArtifactPath,
+            targetPath: options.targetPath ? path.resolve(options.targetPath) : null,
+            status: "fail",
+            exitCode: 1,
+            summary: {
+                artifact: "fail",
+                attestation: "fail",
+                evidenceSignature: "fail",
+                releaseReady: "fail",
+                releaseGates: "fail"
+            },
+            checks: [
+                {
+                    id: "release_evidence.artifact.invalid",
+                    status: "fail",
+                    message: "The release evidence artifact is not a valid doctor release evidence bundle."
+                }
+            ],
+            attestation: null
+        };
+    }
+    const targetPath = path.resolve(options.targetPath);
+    const attestation = await verifyDoctorAttestationObject(artifact.attestation, targetPath, {
+        signingKey: options.signingKey,
+        artifactPath: `${resolvedArtifactPath}#attestation`
+    });
+    const unsignedArtifact = { ...artifact };
+    delete unsignedArtifact.evidenceSignature;
+    const expectedEvidenceSignature = signReleaseEvidence(unsignedArtifact, options.signingKey, "verification");
+    const signatureStatus = artifact.evidenceSignature.status === "signed" &&
+        artifact.evidenceSignature.algorithm === "hmac-sha256" &&
+        digestMatches(expectedEvidenceSignature.payloadDigest, artifact.evidenceSignature.payloadDigest) &&
+        digestMatches(expectedEvidenceSignature.digest, artifact.evidenceSignature.digest)
+        ? "pass"
+        : "fail";
+    const checks = [
+        {
+            id: "release_evidence.artifact.valid",
+            status: "pass",
+            message: "The release evidence artifact has the expected schema and kind."
+        },
+        {
+            id: "release_evidence.signature",
+            status: signatureStatus,
+            message: signatureStatus === "pass"
+                ? "The release evidence signature matches the canonical release evidence payload."
+                : "The release evidence signature does not match the canonical release evidence payload."
+        },
+        {
+            id: "release_evidence.release_ready",
+            status: artifact.releaseReady && artifact.status === "pass" ? "pass" : "fail",
+            message: artifact.releaseReady && artifact.status === "pass"
+                ? "The release evidence bundle reports releaseReady=true and status=pass."
+                : "The release evidence bundle was not release-ready when it was created."
+        },
+        {
+            id: "release_evidence.release_gates",
+            status: artifact.releaseGates.status === "pass" &&
+                artifact.releaseGates.checks.every((check) => check.status === "pass")
+                ? "pass"
+                : "fail",
+            message: artifact.releaseGates.status === "pass"
+                ? "All recorded release gates passed."
+                : "One or more recorded release gates failed."
+        },
+        {
+            id: "release_evidence.attestation",
+            status: attestation.status,
+            message: attestation.status === "pass"
+                ? "The embedded signed attestation verifies against the target package."
+                : "The embedded signed attestation does not verify against the target package."
+        }
+    ];
+    const failedChecks = checks.filter((check) => check.status === "fail");
+    return {
+        schemaVersion: "1.0.0",
+        kind: "doctor.release.evidence.verification",
+        generatedAt: new Date().toISOString(),
+        artifactPath: resolvedArtifactPath,
+        targetPath,
+        status: failedChecks.length === 0 ? "pass" : "fail",
+        exitCode: failedChecks.length === 0 ? 0 : 1,
+        summary: {
+            artifact: "pass",
+            attestation: attestation.status,
+            evidenceSignature: signatureStatus,
+            releaseReady: checks.find((check) => check.id === "release_evidence.release_ready")?.status ?? "fail",
+            releaseGates: checks.find((check) => check.id === "release_evidence.release_gates")?.status ?? "fail"
+        },
+        checks,
+        attestation
+    };
+}
+export function renderDoctorReleaseEvidenceVerificationJson(report) {
+    return JSON.stringify(redactValue(report), null, 2);
+}
+export function renderDoctorReleaseEvidenceVerification(report, options = {}) {
+    const lines = [
+        "Doctor Release Evidence Verification",
+        "====================================",
+        `Artifact: ${report.artifactPath}`,
+        `Target: ${report.targetPath ?? "unknown"}`,
+        `Status: ${report.status.toUpperCase()}`,
+        `Attestation: ${report.summary.attestation.toUpperCase()}`,
+        `Release ready: ${report.summary.releaseReady.toUpperCase()}`,
+        `Release gates: ${report.summary.releaseGates.toUpperCase()}`
+    ];
+    if (options.outputPath) {
+        lines.push(`Output: ${options.outputPath}`);
+    }
+    lines.push("", "Checks", "------");
+    for (const check of report.checks) {
+        lines.push(`${check.status === "pass" ? "PASS" : "FAIL"} ${check.id}`);
+        lines.push(`  ${check.message}`);
+    }
+    return lines.join("\n");
+}
+export function buildDoctorReleaseEvidenceAssetReport(evidence, options) {
+    const artifactPath = path.resolve(options.artifactPath);
+    const status = evidence.status === "pass" && evidence.releaseReady
+        ? "pass"
+        : "fail";
+    return {
+        schemaVersion: "1.0.0",
+        kind: "doctor.release.evidence.asset",
+        generatedAt: new Date().toISOString(),
+        version: packageVersion,
+        targetPath: evidence.targetPath,
+        tag: options.tag,
+        artifactPath,
+        status,
+        exitCode: status === "pass" ? 0 : 1,
+        uploaded: options.uploaded,
+        uploadCommand: [
+            "gh",
+            "release",
+            "upload",
+            options.tag,
+            artifactPath,
+            "--clobber"
+        ],
+        releaseEvidence: {
+            status: evidence.status,
+            releaseReady: evidence.releaseReady,
+            evidenceSignature: evidence.evidenceSignature.status
+        }
+    };
+}
+export function renderDoctorReleaseEvidenceAssetJson(report) {
+    return JSON.stringify(redactValue(report), null, 2);
+}
+export function renderDoctorReleaseEvidenceAsset(report) {
+    return [
+        "Doctor Release Evidence Asset",
+        "=============================",
+        `Target: ${report.targetPath}`,
+        `Tag: ${report.tag}`,
+        `Artifact: ${report.artifactPath}`,
+        `Status: ${report.status.toUpperCase()}`,
+        `Uploaded: ${report.uploaded ? "yes" : "no"}`,
+        `Upload command: ${report.uploadCommand.join(" ")}`
+    ].join("\n");
+}
+export function renderDoctorReleaseEvidence(report) {
+    return [
+        "Doctor Release Evidence",
+        "=======================",
+        `Target: ${report.targetPath}`,
+        `Status: ${report.status.toUpperCase()}`,
+        `Release ready: ${report.releaseReady ? "yes" : "no"}`,
+        `Attestation: ${report.summary.attestation.toUpperCase()}`,
+        `Attestation verification: ${report.summary.attestationVerification.toUpperCase()}`,
+        `Corpus: ${report.summary.corpus.toUpperCase()}`,
+        `Performance: ${report.summary.performance.toUpperCase()}`,
+        `Release gates: ${report.summary.releaseGates.toUpperCase()}`,
+        `Security: ${report.summary.security.toUpperCase()} (${report.security.score}/100)`,
+        `Trust: ${report.summary.trust.toUpperCase()} (${report.trust.score}/100)`,
+        `Git commit: ${report.git.commit ?? "unknown"}`,
+        `Git tag: ${report.git.tag ?? "not tagged"}`
+    ].join("\n");
+}

package/dist/index.d.ts

@@ -9,6 +9,7 @@ export { buildDoctorOutputContract, renderDoctorOutputContract, renderDoctorOutp
 export { buildDoctorValidationCorpusReport, renderDoctorValidationCorpusJson, renderDoctorValidationCorpusReport, type BuildDoctorValidationCorpusOptions, type DoctorValidationCorpusReport, type ValidationCorpusCaseDefinition, type ValidationCorpusCaseResult } from "./core/validation-corpus.js";
 export { buildDoctorExportBundleFromAnalysis, buildDoctorRecommendationsFromAnalysis, buildPackageAnalysis, type PackageAnalysis, type PackageAnalysisOptions, type PackageAnalysisStage, type PackageAnalysisTiming } from "./core/package-analysis.js";
 export { buildDoctorPerformanceReport, renderDoctorPerformanceReport, renderDoctorPerformanceReportJson, type BuildDoctorPerformanceReportOptions, type DoctorPerformanceReport, type DoctorPerformanceStage, type DoctorPerformanceStageName } from "./core/performance-report.js";
+export { buildDoctorReleaseEvidenceAssetReport, buildDoctorReleaseEvidenceReport, renderDoctorReleaseEvidenceAsset, renderDoctorReleaseEvidenceAssetJson, renderDoctorReleaseEvidence, renderDoctorReleaseEvidenceJson, renderDoctorReleaseEvidenceVerification, renderDoctorReleaseEvidenceVerificationJson, verifyDoctorReleaseEvidence, type BuildDoctorReleaseEvidenceOptions, type DoctorReleaseEvidenceAssetReport, type DoctorReleaseEvidenceGitMetadata, type DoctorReleaseEvidencePackageMetadata, type DoctorReleaseEvidenceReport, type DoctorReleaseEvidenceVerificationReport } from "./core/release-evidence.js";
 export { buildDoctorNpmPackageReport, renderDoctorNpmPackageReport, renderDoctorNpmPackageReportJson, type BuildDoctorNpmPackageReportOptions, type DoctorNpmPackageReport } from "./core/npm-package-doctor.js";
 export { buildDoctorRiskDiffReport, renderDoctorRiskDiffReport, renderDoctorRiskDiffReportJson, type BuildDoctorRiskDiffReportOptions, type DoctorRiskDiffReport, type RiskDiffFinding, type RiskFindingCategory } from "./core/risk-diff.js";
 export { buildDoctorInspectorReport, renderDoctorInspectorReport, renderDoctorInspectorReportJson, type BuildDoctorInspectorReportOptions, type DoctorInspectorReport } from "./core/inspector-bridge.js";

package/dist/index.js

@@ -9,6 +9,7 @@ export { buildDoctorOutputContract, renderDoctorOutputContract, renderDoctorOutp
 export { buildDoctorValidationCorpusReport, renderDoctorValidationCorpusJson, renderDoctorValidationCorpusReport } from "./core/validation-corpus.js";
 export { buildDoctorExportBundleFromAnalysis, buildDoctorRecommendationsFromAnalysis, buildPackageAnalysis } from "./core/package-analysis.js";
 export { buildDoctorPerformanceReport, renderDoctorPerformanceReport, renderDoctorPerformanceReportJson } from "./core/performance-report.js";
+export { buildDoctorReleaseEvidenceAssetReport, buildDoctorReleaseEvidenceReport, renderDoctorReleaseEvidenceAsset, renderDoctorReleaseEvidenceAssetJson, renderDoctorReleaseEvidence, renderDoctorReleaseEvidenceJson, renderDoctorReleaseEvidenceVerification, renderDoctorReleaseEvidenceVerificationJson, verifyDoctorReleaseEvidence } from "./core/release-evidence.js";
 export { buildDoctorNpmPackageReport, renderDoctorNpmPackageReport, renderDoctorNpmPackageReportJson } from "./core/npm-package-doctor.js";
 export { buildDoctorRiskDiffReport, renderDoctorRiskDiffReport, renderDoctorRiskDiffReportJson } from "./core/risk-diff.js";
 export { buildDoctorInspectorReport, renderDoctorInspectorReport, renderDoctorInspectorReportJson } from "./core/inspector-bridge.js";

package/dist/run-cli.d.ts

@@ -13,6 +13,7 @@ export interface CliTerminalContext {
 export interface RunCliOptions {
     terminalContext?: CliTerminalContext;
     runCheckImpl?: typeof runCheck;
+    releaseAssetUploadImpl?: (args: string[]) => Promise<void>;
     resolveLatestVersion?: () => Promise<string>;
 }
 export declare function runCli(args: string[], io?: CliIo, options?: RunCliOptions): Promise<number>;

package/dist/run-cli.js

@@ -20,6 +20,7 @@ import { buildDoctorAttestation, renderDoctorAttestation, renderDoctorAttestatio
 import { buildDoctorOutputContract, renderDoctorOutputContract, renderDoctorOutputContractJson } from "./core/output-contract.js";
 import { buildDoctorValidationCorpusReport, renderDoctorValidationCorpusJson, renderDoctorValidationCorpusReport } from "./core/validation-corpus.js";
 import { buildDoctorPerformanceReport, renderDoctorPerformanceReport, renderDoctorPerformanceReportJson } from "./core/performance-report.js";
+import { buildDoctorReleaseEvidenceAssetReport, buildDoctorReleaseEvidenceReport, renderDoctorReleaseEvidenceAsset, renderDoctorReleaseEvidenceAssetJson, renderDoctorReleaseEvidence, renderDoctorReleaseEvidenceJson, renderDoctorReleaseEvidenceVerification, renderDoctorReleaseEvidenceVerificationJson, verifyDoctorReleaseEvidence } from "./core/release-evidence.js";
 import { buildDoctorNpmPackageReport, renderDoctorNpmPackageReport, renderDoctorNpmPackageReportJson } from "./core/npm-package-doctor.js";
 import { buildDoctorRiskDiffReport, renderDoctorRiskDiffReport, renderDoctorRiskDiffReportJson } from "./core/risk-diff.js";
 import { buildDoctorInspectorReport, renderDoctorInspectorReport, renderDoctorInspectorReportJson } from "./core/inspector-bridge.js";
@@ -69,7 +70,7 @@ const defaultIo = {
     }
 };
 function printUsage(io) {
-    io.writeStderr("Usage: codex-plugin-doctor check <path|--installed> [filter] [--policy codex-publish|mcp-strict|security] [--compat] [--json|--markdown|--badge-json|--badge-markdown] [--output <path>] [--history <path>] [--runtime] [--verbose-runtime] [--explain] [--no-animations] [--ascii]\n       codex-plugin-doctor audit --installed [filter] [--policy codex-publish|mcp-strict|security] [--security] [--compat] [--json] [--output <path>] [--cache] [--changed]\n       codex-plugin-doctor mcp <path> [--json] [--output <path>]\n       codex-plugin-doctor security <path> [--policy security] [--json|--scorecard]\n       codex-plugin-doctor compat <path> [--all|--client <client>] [--json] [--scorecard] [--output <path>] [--install-preview|--apply --backup]\n       codex-plugin-doctor fix <path> (--dry-run|--interactive --backup|--apply --backup)\n       codex-plugin-doctor history <history.jsonl> [--json] [--fail-on-regression]\n       codex-plugin-doctor doctor [npm <package>|contract|corpus|attest <path> [--sign-key-env NAME]|attest verify <attestation.json> --target <path> --sign-key-env NAME|mcp <path>|inspector <path>|diff --before <path> --after <path>|recommend <path>|trust <path>|perf <path> [--max-total-ms <ms>] [--max-stage-ms stage=ms]|export --bundle <path>|snapshot|clients|--json|--update-check]\n       codex-plugin-doctor init [path] [--template skill-only|mcp-stdio|mcp-http|full-runtime]\n       codex-plugin-doctor init-ci [path]\n       codex-plugin-doctor self-test\n       codex-plugin-doctor list --installed\n       codex-plugin-doctor explain <finding-id>\n       codex-plugin-doctor --version\n\nFirst run:\n       codex-plugin-doctor doctor\n       codex-plugin-doctor self-test\n       codex-plugin-doctor init my-plugin\n       codex-plugin-doctor check . --runtime --explain");
+    io.writeStderr("Usage: codex-plugin-doctor check <path|--installed> [filter] [--policy codex-publish|mcp-strict|security] [--compat] [--json|--markdown|--badge-json|--badge-markdown] [--output <path>] [--history <path>] [--runtime] [--verbose-runtime] [--explain] [--no-animations] [--ascii]\n       codex-plugin-doctor audit --installed [filter] [--policy codex-publish|mcp-strict|security] [--security] [--compat] [--json] [--output <path>] [--cache] [--changed]\n       codex-plugin-doctor mcp <path> [--json] [--output <path>]\n       codex-plugin-doctor security <path> [--policy security] [--json|--scorecard]\n       codex-plugin-doctor compat <path> [--all|--client <client>] [--json] [--scorecard] [--output <path>] [--install-preview|--apply --backup]\n       codex-plugin-doctor fix <path> (--dry-run|--interactive --backup|--apply --backup)\n       codex-plugin-doctor history <history.jsonl> [--json] [--fail-on-regression]\n       codex-plugin-doctor doctor [npm <package>|contract|corpus|attest <path> [--sign-key-env NAME]|attest verify <attestation.json> --target <path> --sign-key-env NAME|release-evidence <path> --sign-key-env NAME [--allow-dirty] [--allow-untagged]|release-evidence verify <evidence.json> --target <path> --sign-key-env NAME|release-evidence asset <path> --tag <tag> --output <evidence.json> --sign-key-env NAME [--upload]|mcp <path>|inspector <path>|diff --before <path> --after <path>|recommend <path>|trust <path>|perf <path> [--max-total-ms <ms>] [--max-stage-ms stage=ms]|export --bundle <path>|snapshot|clients|--json|--update-check]\n       codex-plugin-doctor init [path] [--template skill-only|mcp-stdio|mcp-http|full-runtime]\n       codex-plugin-doctor init-ci [path]\n       codex-plugin-doctor self-test\n       codex-plugin-doctor list --installed\n       codex-plugin-doctor explain <finding-id>\n       codex-plugin-doctor --version\n\nFirst run:\n       codex-plugin-doctor doctor\n       codex-plugin-doctor self-test\n       codex-plugin-doctor init my-plugin\n       codex-plugin-doctor check . --runtime --explain");
 }
 const performanceStageNames = new Set([
     "validation",
@@ -218,6 +219,17 @@ async function resolveLatestNpmVersion() {
         });
     });
 }
+async function uploadGitHubReleaseAsset(args) {
+    return new Promise((resolve, reject) => {
+        execFile("gh", args, { shell: process.platform === "win32" }, (error, _stdout, stderr) => {
+            if (error) {
+                reject(new Error(stderr.trim() || error.message));
+                return;
+            }
+            resolve();
+        });
+    });
+}
 function renderUpdateCheck(latestVersion) {
     const updateAvailable = latestVersion !== packageVersion;
     return [
@@ -339,6 +351,219 @@ export async function runCli(args, io = defaultIo, options = {}) {
             io.writeStdout(renderedReport);
             return report.exitCode;
         }
+        if (maybePath === "release-evidence") {
+            if (remainingArgs[0] === "asset") {
+                const targetPath = remainingArgs[1] && !remainingArgs[1].startsWith("--")
+                    ? remainingArgs[1]
+                    : null;
+                const assetFlags = targetPath ? remainingArgs.slice(2) : remainingArgs.slice(1);
+                const jsonOutput = assetFlags.includes("--json");
+                const upload = assetFlags.includes("--upload");
+                const outputIndex = assetFlags.indexOf("--output");
+                const outputPath = outputIndex === -1 ? null : assetFlags[outputIndex + 1];
+                const tagIndex = assetFlags.indexOf("--tag");
+                const tag = tagIndex === -1 ? null : assetFlags[tagIndex + 1];
+                const signKeyIndex = assetFlags.indexOf("--sign-key");
+                const signKeyEnvIndex = assetFlags.indexOf("--sign-key-env");
+                const signKeyEnv = signKeyEnvIndex === -1 ? null : assetFlags[signKeyEnvIndex + 1];
+                const allowDirty = assetFlags.includes("--allow-dirty");
+                const allowUntagged = assetFlags.includes("--allow-untagged");
+                if (!targetPath) {
+                    io.writeStderr("Missing target path for release evidence asset.");
+                    return 2;
+                }
+                if (tagIndex === -1) {
+                    io.writeStderr("Missing release tag. Use --tag <tag>.");
+                    return 2;
+                }
+                if (!tag || tag.startsWith("--")) {
+                    io.writeStderr("Missing release tag after --tag.");
+                    return 2;
+                }
+                if (outputIndex === -1) {
+                    io.writeStderr("Missing output path. Use --output <path>.");
+                    return 2;
+                }
+                if (!outputPath || outputPath.startsWith("--")) {
+                    io.writeStderr("Missing path after --output.");
+                    return 2;
+                }
+                if (signKeyIndex !== -1) {
+                    io.writeStderr("Use --sign-key-env for release evidence assets; inline signing keys are not supported.");
+                    return 2;
+                }
+                if (signKeyEnvIndex === -1) {
+                    io.writeStderr("Missing signing key. Use --sign-key-env <name>.");
+                    return 2;
+                }
+                if (!signKeyEnv || signKeyEnv.startsWith("--")) {
+                    io.writeStderr("Missing environment variable name after --sign-key-env.");
+                    return 2;
+                }
+                const signingKey = terminalContext.env[signKeyEnv];
+                if (!signingKey) {
+                    io.writeStderr(`Environment variable ${signKeyEnv} is not set.`);
+                    return 2;
+                }
+                const parsedThresholds = parsePerformanceThresholds(assetFlags);
+                if (typeof parsedThresholds === "string") {
+                    io.writeStderr(parsedThresholds);
+                    return 2;
+                }
+                const resolvedOutputPath = path.resolve(outputPath);
+                const evidence = await buildDoctorReleaseEvidenceReport(targetPath, {
+                    signingKey,
+                    signingKeyEnv: signKeyEnv,
+                    allowDirty,
+                    allowUntagged,
+                    environment: {
+                        env: terminalContext.env,
+                        platform: terminalContext.platform
+                    },
+                    runCheck: options.runCheckImpl
+                        ? (pathToCheck) => options.runCheckImpl(pathToCheck)
+                        : undefined,
+                    performanceThresholds: parsedThresholds.thresholds
+                });
+                await writeFile(resolvedOutputPath, renderDoctorReleaseEvidenceJson(evidence), "utf8");
+                let uploaded = false;
+                const uploadArgs = ["release", "upload", tag, resolvedOutputPath, "--clobber"];
+                if (upload && evidence.status === "pass" && evidence.releaseReady) {
+                    const uploadImpl = options.releaseAssetUploadImpl ?? uploadGitHubReleaseAsset;
+                    await uploadImpl(uploadArgs);
+                    uploaded = true;
+                }
+                const report = buildDoctorReleaseEvidenceAssetReport(evidence, {
+                    tag,
+                    artifactPath: resolvedOutputPath,
+                    uploaded
+                });
+                const reportJson = renderDoctorReleaseEvidenceAssetJson(report);
+                io.writeStdout(jsonOutput ? reportJson : renderDoctorReleaseEvidenceAsset(report));
+                return report.exitCode;
+            }
+            if (remainingArgs[0] === "verify") {
+                const artifactPath = remainingArgs[1] && !remainingArgs[1].startsWith("--")
+                    ? remainingArgs[1]
+                    : null;
+                const verifyFlags = artifactPath ? remainingArgs.slice(2) : remainingArgs.slice(1);
+                const jsonOutput = verifyFlags.includes("--json");
+                const outputIndex = verifyFlags.indexOf("--output");
+                const outputPath = outputIndex === -1 ? null : verifyFlags[outputIndex + 1];
+                const targetIndex = verifyFlags.indexOf("--target");
+                const targetPath = targetIndex === -1 ? null : verifyFlags[targetIndex + 1];
+                const signKeyIndex = verifyFlags.indexOf("--sign-key");
+                const signKeyEnvIndex = verifyFlags.indexOf("--sign-key-env");
+                const signKeyEnv = signKeyEnvIndex === -1 ? null : verifyFlags[signKeyEnvIndex + 1];
+                if (!artifactPath) {
+                    io.writeStderr("Missing release evidence artifact path.");
+                    return 2;
+                }
+                if (outputIndex !== -1 && (!outputPath || outputPath.startsWith("--"))) {
+                    io.writeStderr("Missing path after --output.");
+                    return 2;
+                }
+                if (targetIndex !== -1 && (!targetPath || targetPath.startsWith("--"))) {
+                    io.writeStderr("Missing path after --target.");
+                    return 2;
+                }
+                if (targetIndex === -1) {
+                    io.writeStderr("Missing target path. Use --target <path>.");
+                    return 2;
+                }
+                if (signKeyIndex !== -1) {
+                    io.writeStderr("Use --sign-key-env for release evidence verification; inline signing keys are not supported.");
+                    return 2;
+                }
+                if (signKeyEnvIndex === -1) {
+                    io.writeStderr("Missing signing key. Use --sign-key-env <name>.");
+                    return 2;
+                }
+                if (!signKeyEnv || signKeyEnv.startsWith("--")) {
+                    io.writeStderr("Missing environment variable name after --sign-key-env.");
+                    return 2;
+                }
+                const signingKey = terminalContext.env[signKeyEnv];
+                if (!signingKey) {
+                    io.writeStderr(`Environment variable ${signKeyEnv} is not set.`);
+                    return 2;
+                }
+                const report = await verifyDoctorReleaseEvidence(artifactPath, {
+                    signingKey,
+                    targetPath: targetPath
+                });
+                const reportJson = renderDoctorReleaseEvidenceVerificationJson(report);
+                const renderedReport = jsonOutput
+                    ? reportJson
+                    : renderDoctorReleaseEvidenceVerification(report, { outputPath });
+                if (outputPath) {
+                    await writeFile(outputPath, reportJson, "utf8");
+                }
+                io.writeStdout(renderedReport);
+                return report.exitCode;
+            }
+            const targetPath = remainingArgs[0] && !remainingArgs[0].startsWith("--")
+                ? remainingArgs[0]
+                : ".";
+            const evidenceFlags = remainingArgs[0] && !remainingArgs[0].startsWith("--")
+                ? remainingArgs.slice(1)
+                : remainingArgs;
+            const jsonOutput = evidenceFlags.includes("--json");
+            const outputIndex = evidenceFlags.indexOf("--output");
+            const outputPath = outputIndex === -1 ? null : evidenceFlags[outputIndex + 1];
+            const signKeyIndex = evidenceFlags.indexOf("--sign-key");
+            const signKeyEnvIndex = evidenceFlags.indexOf("--sign-key-env");
+            const signKeyEnv = signKeyEnvIndex === -1 ? null : evidenceFlags[signKeyEnvIndex + 1];
+            const allowDirty = evidenceFlags.includes("--allow-dirty");
+            const allowUntagged = evidenceFlags.includes("--allow-untagged");
+            if (outputIndex !== -1 && (!outputPath || outputPath.startsWith("--"))) {
+                io.writeStderr("Missing path after --output.");
+                return 2;
+            }
+            if (signKeyIndex !== -1) {
+                io.writeStderr("Use --sign-key-env for release evidence; inline signing keys are not supported.");
+                return 2;
+            }
+            if (signKeyEnvIndex === -1) {
+                io.writeStderr("Missing signing key. Use --sign-key-env <name>.");
+                return 2;
+            }
+            if (!signKeyEnv || signKeyEnv.startsWith("--")) {
+                io.writeStderr("Missing environment variable name after --sign-key-env.");
+                return 2;
+            }
+            const signingKey = terminalContext.env[signKeyEnv];
+            if (!signingKey) {
+                io.writeStderr(`Environment variable ${signKeyEnv} is not set.`);
+                return 2;
+            }
+            const parsedThresholds = parsePerformanceThresholds(evidenceFlags);
+            if (typeof parsedThresholds === "string") {
+                io.writeStderr(parsedThresholds);
+                return 2;
+            }
+            const report = await buildDoctorReleaseEvidenceReport(targetPath, {
+                signingKey,
+                signingKeyEnv: signKeyEnv,
+                allowDirty,
+                allowUntagged,
+                environment: {
+                    env: terminalContext.env,
+                    platform: terminalContext.platform
+                },
+                runCheck: options.runCheckImpl
+                    ? (pathToCheck) => options.runCheckImpl(pathToCheck)
+                    : undefined,
+                performanceThresholds: parsedThresholds.thresholds
+            });
+            const reportJson = renderDoctorReleaseEvidenceJson(report);
+            const renderedReport = jsonOutput ? reportJson : renderDoctorReleaseEvidence(report);
+            if (outputPath) {
+                await writeFile(outputPath, reportJson, "utf8");
+            }
+            io.writeStdout(renderedReport);
+            return report.exitCode;
+        }
         if (maybePath === "corpus") {
             const jsonOutput = remainingArgs.includes("--json");
             const outputIndex = remainingArgs.indexOf("--output");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-plugin-doctor",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "CLI-first validator for Codex plugins, skills, and MCP package surfaces with runtime MCP protocol validation.",
   "type": "module",
   "main": "./dist/index.js",