@dzhechkov/harness-cli 0.3.232 → 0.3.234

package/.dz-manifest.json

@@ -0,0 +1,137 @@
+{
+  "manifest": {
+    "version": 1,
+    "pack": "harness-cli",
+    "files": [
+      {
+        "path": ".agentic-qe/brain.rvf",
+        "sha256": "8136cd4cc145d3dbe6ed3ae4489946bbc26e3e44172f0e5241ac45dde38bfead"
+      },
+      {
+        "path": ".agentic-qe/brain.rvf.lock",
+        "sha256": "96c3f61d34c63a8adf2a87cd10abc73b09946223798a543d2c477f6486ceba2b"
+      },
+      {
+        "path": ".agentic-qe/memory.db",
+        "sha256": "456372cb9a8c12f98ae6378338b8469d9be6df05cbe03a99b412d83d962b3d11"
+      },
+      {
+        "path": ".agentic-qe/memory.db-shm",
+        "sha256": "613a87ec0ce8a7cc48d1b6939999ac623c144ff5718f04b40b9d26519f517af2"
+      },
+      {
+        "path": ".agentic-qe/memory.db-wal",
+        "sha256": "8b037ea49fcdf20ebbe02798aaa6b5cdddd5cadd1f7239c629650093afd5ac2f"
+      },
+      {
+        "path": ".agentic-qe/patterns.rvf",
+        "sha256": "9090b2e6d339eaa183672ac0cf9f625dbd5f9fc76d64afcdb34a3f5871c31c5a"
+      },
+      {
+        "path": ".agentic-qe/patterns.rvf.idmap.json",
+        "sha256": "c2693f9a7f47a2d2bffe3004188e70ce08411bf8db47d07c60551d18ff7640c4"
+      },
+      {
+        "path": ".agentic-qe/patterns.rvf.lock",
+        "sha256": "ad77ee665c75491a8700381fb79205d308653e99a15013564c7732eeb6aa1181"
+      },
+      {
+        "path": "CHANGELOG.md",
+        "sha256": "9555ead768fef7963e735b0c6af21a64412811531534108be3df61bc65b51021"
+      },
+      {
+        "path": "README.md",
+        "sha256": "4a11112ac688fbc833439ec9d047da01abf0981189edf611f198dc36ae7c34ec"
+      },
+      {
+        "path": "coverage/coverage-final.json",
+        "sha256": "1abb00d07ab57ad413d2747baa6a68cda0876a9e0c6f75db89c205fbf4863530"
+      },
+      {
+        "path": "coverage/coverage-summary.json",
+        "sha256": "42d2a98f54c2ec773b49a0a43c959a78d070c8c427724f4affbd5bafef35621d"
+      },
+      {
+        "path": "dist/bin.d.ts",
+        "sha256": "58be9f04d2fe63cca2efe3957b9933068e443a0e57f9838ff9ef800cc191e03f"
+      },
+      {
+        "path": "dist/bin.d.ts.map",
+        "sha256": "b1e41c8c19fa56ae9dec2267740eb4389bc785431478861a8843867f99c1b25b"
+      },
+      {
+        "path": "dist/bin.js",
+        "sha256": "ad24e06de21b036e2b5a43abc4efd6e7ceb2ae126177b218a3ee13a026641f83"
+      },
+      {
+        "path": "dist/bin.js.map",
+        "sha256": "c2dd399fec3f26e48e23971b29e27c508c1a1f96376a193e72dc8042015c8e65"
+      },
+      {
+        "path": "dist/cli.d.ts",
+        "sha256": "628c55bb864dd8a8f337a9cb3fe4271f0df7c0bf9237b1150427171f0577fd57"
+      },
+      {
+        "path": "dist/cli.d.ts.map",
+        "sha256": "8c3b6f509c494ff446a098239f39453510a385f879d86127e91a528287b32333"
+      },
+      {
+        "path": "dist/cli.js",
+        "sha256": "0ea78654ed97065078affc088022d25406568345f30aaf87ec30533b1537110a"
+      },
+      {
+        "path": "dist/cli.js.map",
+        "sha256": "8fc984391e8ff91464f32e73d36253f292d558e2bb2676b2a18e474d8d1861d5"
+      },
+      {
+        "path": "dist/index.d.ts",
+        "sha256": "aaac0134a074fd06e9b5e09daa952ef6353510e481885da51a6e4f2e92beba35"
+      },
+      {
+        "path": "dist/index.d.ts.map",
+        "sha256": "459c3381a9fbcd3378b623f9fe103a8d3337e4025a2f546b6d40e4d9dd4e0f70"
+      },
+      {
+        "path": "dist/index.js",
+        "sha256": "15ff1e6b84537b91b73b6a7e2d1c45f1120b25af9d1139df8da8ad094e99cf0e"
+      },
+      {
+        "path": "dist/index.js.map",
+        "sha256": "2f61a3be1af4ab9f7bbcbacb912ccbd89e3b73414f9fd24766598bfbdc1f8655"
+      },
+      {
+        "path": "keys/README.md",
+        "sha256": "204deec657a7f147bf3016441082c2f868f6f11051776f4edc13ec6b44745192"
+      },
+      {
+        "path": "package.json",
+        "sha256": "68a09fba4c6068dd171738166ad659097bf99d08b8a80ca504ad5109148b4eb5"
+      },
+      {
+        "path": "src/bin.ts",
+        "sha256": "a0d4e20fafc5cba35816f1f0c6cd03d9ce7c4434d2ca049384491079d2408fd4"
+      },
+      {
+        "path": "src/cli.ts",
+        "sha256": "af5541d8bd97570102b8df85b6ed598813b8d53ede9cc71533e40b808d5c033e"
+      },
+      {
+        "path": "src/index.ts",
+        "sha256": "395b27b317e575b94a1049cdb284db185e0ec382fbae1e588c78ff2398b2563f"
+      },
+      {
+        "path": "test/cli.test.ts",
+        "sha256": "73b554b9f78681d9e1dd168b945bac427bcf027e11125157d8b4ab5e2b25dc22"
+      },
+      {
+        "path": "tsconfig.json",
+        "sha256": "e80ef2911c3347a713dc3dca6a5f6034d91e938e58e71345ea920dd9833bcdbb"
+      },
+      {
+        "path": "vitest.config.ts",
+        "sha256": "a6ffc6172b50a3a59010f8f8c66e2204e7d298b62a7f2bc5de33cbf39c99899d"
+      }
+    ]
+  },
+  "signature": "XO+n3VwYnhgXfKF8nBdxZ4ALrmUgXX+3OSBzauqpk9UV8/PVbKLHspZQ2Pfu9zO7wIcharU8f+NF/GXMGCyWDw=="
+}

package/README.md

@@ -241,6 +241,11 @@ dz roam --apply                                 # sync agent state across machin
 ### Phase 6: Share (publish to the world)
 
 ```bash
+# Verified release — 4 HARD gates (tests, audit, syntax, smoke-boot) in FRONT of dz publish:
+dz release --dry-run                            # print the full gate plan, execute nothing
+dz release --filter skills-devops --tag         # gates for one release set; on green: git tag + notes
+dz release                                      # gates for the whole workspace; green prints the ready dz publish command
+
 # Publish updated packages to npm:
 dz publish --dry-run                            # preview
 dz publish --filter skills-devops               # publish specific package
@@ -307,7 +312,9 @@ dz sbom --pack packages/@dzhechkov/skills-qe --out sbom.json # write to a file
 ```
 
 A single flipped byte, a deleted file, or an **added** file all fail verification and the offending
-path is named. Every degenerate input (no manifest, empty file list, empty signature, no public key)
+path is named. `node_modules`/`.git` are unsigned territory by design (npm ships neither) — the sign and
+verify walks share those exclusions, while a symlink smuggled anywhere ELSE in the pack still fails loudly.
+Re-sign after ANY pack change (the manifest hashes `package.json` too) — sign is the LAST step before publish. Every degenerate input (no manifest, empty file list, empty signature, no public key)
 fails **closed** — absence never reads as success. `dz doctor` **and** `dz drift-check` run this check
 over the installed packs: a **tampered** pack is fatal (blocks); an **unsigned** pack or a missing trust
 root is reported, not fatal (transitional — the existing packs are not yet signed).
@@ -327,7 +334,7 @@ every run; `--require-signing` turns that into a refusal today.
 verifies what it just installed. A pack that does not match its signed manifest is **fatal**:
 
 ```bash
-dz doctor                      # ... signatures: 3 verified, 0 unsigned, 0 TAMPERED, 0 unverifiable
+dz doctor                      # ... signatures: 23 verified, 0 unsigned, 0 TAMPERED (the gate is ARMED: keys/dz.pub committed)
 dz doctor --require-signing    # an unsigned pack becomes fatal too
 dz upgrade                     # a TAMPERED pack aborts the upgrade
 dz doctor --pubkey ./my.pub    # verify against a key you pinned yourself
@@ -365,6 +372,37 @@ the release job gets a perfectly attested malicious package.
 A ready-to-install workflow is at `features/publish-provenance/07_code_changes/publish.yml`; copy it to
 `.github/workflows/` and add an `NPM_TOKEN` secret.
 
+### Verified release — `dz release` (4 HARD gates in front of `dz publish`)
+
+`dz publish` gates on guard / claim-check / signatures / provenance / files-whitelist — none of which
+prove the code **works**. `dz release` is the opt-in VERIFY phase in front of it: (1) each package's full
+test suite, (2) `pnpm audit --prod --audit-level high` (production deps by default — a dev-only advisory
+is not a false gate; `--audit-dev` widens; an audit that *cannot run* also blocks, classified
+`AUDIT_ERROR`), (3) `node --check` of every `dist/**/*.js` + bin file (a dist older than `src/` is
+`STALE_DIST`, never checked as-is; a package that declares a `build` script but has **no** dist JS is
+`MISSING_DIST` — an unbuilt package cannot ship), (4) smoke-boot every bin via `node <bin> --help` in a
+throwaway cwd with a timeout. Packages without a `test` script are **named skips** in the report — never
+silent passes; a template-only pack (no build, no artifacts, no bin) is a named `SKIP_NO_ARTIFACTS`.
+
+```bash
+dz release --dry-run              # full gate plan, zero commands executed
+dz release --filter harness-core  # gates for one release set
+dz release --affected             # narrow to packages touched by working tree + last commit (git down ⇒ FAIL-OPEN to full set)
+dz release --tag                  # on green: annotated git tag + short notes from recent commits
+dz release --publish              # on green: chain in-process into dz publish (its own dry-run protocol)
+dz release --json                 # CI-parseable verdict; valid JSON on error paths too (with --publish, publish output rides INSIDE the envelope)
+dz release --audit-dev            # widen the audit gate to dev dependencies too
+```
+
+Expected flow: gate table (`✓/✗/○` per gate with per-package failures + named skips) → on any red gate:
+release STOPPED, exit 1, best-effort `gh issue create` (no `gh`/network ⇒ loud log, never a block;
+note: the issue body embeds first lines of failing output — pass `--no-issue` on public repos when
+test/audit output may carry paths or environment details) → on
+green: re-sign reminder (`dz sign …` — the publish signature gate is refuse-unsigned), then the ready
+`dz publish` command printed **without** `--yes`: live publish stays your explicit act. **When to use:**
+before a multi-package npm release, or whenever a broken dist/bin must be impossible to ship; keep plain
+`dz publish` for routine pushes. `dz publish` itself is byte-identical whether or not release exists.
+
 ### Skill Packs (23 packs · 179 skills)
 
 Each pack is an npm package — click through for the **full per-skill documentation** (what each skill does + how to trigger it). Install a whole pack with `dz install <pkg>`, or pick skills with `dz init --select` / a `--preset`.
@@ -443,7 +481,7 @@ Get the whole set with `dz init --target claude-code --preset meta`, or pick one
 
 > **A skill and its npx toolkit are not duplicates — they're a graduation.** Several skills (e.g. `feature-adr`, `design-thinking`) exist BOTH as a skill inside a `dz` preset AND as a standalone `npx` package. The preset's SKILL.md is **fully functional on its own** (the whole methodology — modules + references — travels with it, and it auto-activates by description), and it's the only way to compile that capability to the **non-Claude platforms** (Codex/OpenCode/Hermes/OpenClaude) via `dz`. The npx package adds **project-level runtime governance** around the same skill: a slash command, governance rules, a context shard, and (for feature-adr) reward-learning + `/harvest`. So: pick the **skill/preset** for a working capability across platforms; pick the **npx toolkit** when you want it as a governed, command-driven fixture of one project.
 
-## All Commands (54)
+## All Commands (55)
 
 ```
 dz setup             --target <name> [--preset <name>] [--select id,id,...] [--skills-dir <dir>] [--memory agentdb] [--no-memory] [--no-hooks] [--install-driver] [--force]
@@ -503,6 +541,7 @@ dz sbom --pack <dir> [--out <file>]   # emit the CycloneDX 1.5 SBOM for a pack s
 dz guard check --op <publish|teach|consolidate|reindex> [--text <s>] [--json] [--force <reason>]   # declarative constraint layer before self-mutating ops: HARD violation → block (exit 1), SOFT → warn; zero-config defaults, .dz/guard.json to customise; dz guard --init | dz guard log (append-only audit). dz publish runs it automatically (--no-guard "<reason>" = logged escape hatch)
 dz feature-adr-setup --guards [--loc-cap <n>] [--apply]   # P3: scaffold DETERMINISTIC guard tests into the project — guards.config.json + a zero-dependency check.mjs runner (LOC cap, secret scan, frozen-file sha256 pins, waivers-with-reasons); wire `node architecture/guards/check.mjs` into CI
 dz publish           [--filter <name>] [--bump-only] [--claim-check <off|warn|error>]   (dry-run by default; pass --yes/--confirm to go live; claim-check gate defaults to warn — surfaces README claim findings, never blocks)
+dz release           [--filter <name>] [--affected] [--audit-dev] [--tag] [--publish] [--json] [--dry-run] [--no-issue]   # VERIFIED release: 4 HARD gates in front of dz publish — package test suites, pnpm audit --prod >=high (--audit-dev widens), node --check of every dist/bin file (unbuilt package with a build script ⇒ MISSING_DIST fail), bin smoke-boot "node <bin> --help" (temp cwd + timeout); --affected narrows to git-touched packages (fail-open); any red gate STOPS the release (exit 1) + best-effort gh issue; green ⇒ re-sign reminder, then the ready dz publish command (never with --yes injected)
 dz auto-canonicalize --source <github-url> --pack <skills-pack>
 dz sync-upstream     [--package <dir>] [--list] [--all]
 dz drift-check       [--all] [--json] [--project <dir>]   # CI gate: exit 1 on NEW shared-skill drift (baseline: .dz/drift-allowlist.json; --all incl .claude dogfood)
@@ -2059,7 +2098,7 @@ npx @dzhechkov/p-replicator init
 
 ## Status
 
-`v0.3.179` — published on npm. Also available as [Claude Plugin](#claude-plugin). Part of [DZ Harness Hub](https://github.com/djd1m/dz-harness-hub).
+`v0.3.234` — published on npm. Also available as [Claude Plugin](#claude-plugin). Part of [DZ Harness Hub](https://github.com/djd1m/dz-harness-hub).
 
 ## Claude Plugin
 

package/dist/cli.d.ts

@@ -13,6 +13,23 @@ export interface CliIo {
      * command that needs it (`brain ground`), and never when stdin is a TTY (nothing piped).
      */
     readonly stdin?: string;
+    /**
+     * Test seam for `dz release`: overrides subprocess execution for gate steps and the
+     * gh/git side channels (production leaves it unset → real `execSync`, stdio piped).
+     * A scripted runner makes failing gates, gh outages, and git-tag failures testable
+     * without spawning anything.
+     */
+    readonly releaseRunner?: ReleaseExecRunner;
 }
+/** Injected subprocess runner used by `dz release` (see {@link CliIo.releaseRunner}). */
+export type ReleaseExecRunner = (cmd: string, opts: {
+    readonly cwd: string;
+    readonly timeoutMs: number;
+}) => {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    timedOut?: boolean;
+};
 export declare function runCli(argv: string[], io?: CliIo): Promise<number>;
 //# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAiPH,2EAA2E;AAC3E,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AA48JD,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,GAAE,KAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CA4I5E"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AA4PH,2EAA2E;AAC3E,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,iBAAiB,CAAC;CAC5C;AAED,yFAAyF;AACzF,MAAM,MAAM,iBAAiB,GAAG,CAC9B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,KACvD;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAguK9E,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,GAAE,KAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CA8I5E"}

package/dist/cli.js

@@ -9,7 +9,7 @@ import { fileURLToPath } from 'node:url';
 import { execSync } from 'node:child_process';
 import { homedir, tmpdir } from 'node:os';
 import { createRequire } from 'node:module';
-import { createSkill, getSkillInfo, getWorkflow, isTargetName, listSkills, runDoctor, runInit, benchmarkSkill, benchmarkSkills, scanMcp, reconcileCapabilities, RECONCILE_BANNER, buildRegistry, discoverSkillPackDirs, checkUpstream, compareSkills, checkAllUpstream, sweepSkillDrift, syncCanonicalSkill, checkUpgrades, discoverPackages, discoverSourcePackages, fetchAllDownloads, filterByCategory, pretrain, recommend, generatePlugin, publishPackages, runSetup, runMigrate, searchRegistry, runSync, runVerify, runInitAgentsMd, runInitGeminiMd, TARGET_NAMES, WORKFLOW_NAMES, importEcc, recordPattern, resolveLearningBackend, storeStats, consolidateSessions, pruneNoisePatterns, lessonDeltaReport, removePatternsByIds, snapshotStore, recallHybrid, teachGuard, mirrorPatternsToVector, vectorMirrorEnabled, vectorTierStatus, resolveVectorEngine, reindexVectorStore, harmonizeVectorStore, importRvfCheckpoint, statuslineData, writeFeatureAdrState, computeUsage, deriveUsageCalibration, normalizeClaudeUsageModelKey, readUsageLimits, claimCheck, summarize, queryBookKnowledge, loadStorePatternsSync, patternRecordId, loadStoreRecords, recordToPattern, bundleSkills, brainHome, listBrain, promoteProjectToBrain, updateBrainSource, queryBrain, groundPrompt, expandKu, reindexBrainVectors, buildPrimer, exportBrainSlice, importBrainSlice, registerKusToBrain, RECALL_USAGE_LOG_RELATIVE, RECALL_USAGE_LOG_MAX_BYTES, parseRecallUsageLog, buildRecallUsageReport, buildManifest, buildSbom, resolveTrustRoot, decideVerifyPolicy, generateSigningKeypair, evaluateGuard, resolveRules, auditRecord, guardExitCode, DEFAULT_RULES, decideProvenance, isInsideTree, signManifest, verifyManifest, assertKeyOutsideTree, decidePublishGate, MANIFEST_NAME, SBOM_NAME, buildArchitectureMap, renderMapHuman, findArchitectureDrift, renderDriftReport, scanWorkspacePackages, loadSubsystemManifest, loadProductVision, checkFeatureAgainstArchitecture, renderArchCheck, planProjectSkills, guidanceForStage, renderInjectionReport, analyzeCorpus, renderRakeReport, renderCriticSection, rakeAsLesson, rakeReward, DEFAULT_RAKE_THRESHOLDS, streamSessionEvents, findLatestTranscript, detectProcessRakes, buildRetro, renderRetro, retroLessonText, PROCESS_SIGNATURES, RETRO_DOMAIN, scanForSetup, buildSetupPlan, scaffoldFromSpec, renderScaffoldPreview, readExistingForScaffold, assembleChallengeContext, buildChallengeBrief, planDiscriminationCheck, classifyDiscrimination, pickAdversaryModel, CHALLENGE_QUESTIONS, loadOutcomes, renderOutcomes, statsForKey, selectAutoCost, recordProvisional, finalizeOutcome, COST_LADDER, splitScenarios, budgetPlan, selectWinner, proseScopeOk, renderProseDiff, readScenarioIds, DEFAULT_MAX_JUDGE_RUNS, } from '@dzhechkov/harness-core';
+import { createSkill, getSkillInfo, getWorkflow, isTargetName, listSkills, runDoctor, runInit, benchmarkSkill, benchmarkSkills, scanMcp, reconcileCapabilities, RECONCILE_BANNER, buildRegistry, discoverSkillPackDirs, checkUpstream, compareSkills, checkAllUpstream, sweepSkillDrift, syncCanonicalSkill, checkUpgrades, discoverPackages, discoverSourcePackages, fetchAllDownloads, filterByCategory, pretrain, recommend, generatePlugin, publishPackages, runSetup, runMigrate, searchRegistry, runSync, runVerify, runInitAgentsMd, runInitGeminiMd, TARGET_NAMES, WORKFLOW_NAMES, importEcc, recordPattern, resolveLearningBackend, storeStats, consolidateSessions, pruneNoisePatterns, lessonDeltaReport, removePatternsByIds, snapshotStore, recallHybrid, teachGuard, mirrorPatternsToVector, vectorMirrorEnabled, vectorTierStatus, resolveVectorEngine, reindexVectorStore, harmonizeVectorStore, importRvfCheckpoint, statuslineData, writeFeatureAdrState, computeUsage, deriveUsageCalibration, normalizeClaudeUsageModelKey, readUsageLimits, claimCheck, summarize, queryBookKnowledge, loadStorePatternsSync, patternRecordId, loadStoreRecords, recordToPattern, bundleSkills, brainHome, listBrain, promoteProjectToBrain, updateBrainSource, queryBrain, groundPrompt, expandKu, reindexBrainVectors, buildPrimer, exportBrainSlice, importBrainSlice, registerKusToBrain, RECALL_USAGE_LOG_RELATIVE, RECALL_USAGE_LOG_MAX_BYTES, parseRecallUsageLog, buildRecallUsageReport, buildManifest, buildSbom, resolveTrustRoot, decideVerifyPolicy, generateSigningKeypair, evaluateGuard, resolveRules, auditRecord, guardExitCode, DEFAULT_RULES, decideProvenance, isInsideTree, signManifest, verifyManifest, listSignablePackFiles, assertKeyOutsideTree, decidePublishGate, collectPackageFacts, planReleaseGates, selectAffectedPackages, classifyGateExecutions, buildFailureIssue, buildReleaseNotes, releaseTagName, firstOutputLine, formatPublishError, MANIFEST_NAME, SBOM_NAME, buildArchitectureMap, renderMapHuman, findArchitectureDrift, renderDriftReport, scanWorkspacePackages, loadSubsystemManifest, loadProductVision, checkFeatureAgainstArchitecture, renderArchCheck, planProjectSkills, guidanceForStage, renderInjectionReport, analyzeCorpus, renderRakeReport, renderCriticSection, rakeAsLesson, rakeReward, DEFAULT_RAKE_THRESHOLDS, streamSessionEvents, findLatestTranscript, detectProcessRakes, buildRetro, renderRetro, retroLessonText, PROCESS_SIGNATURES, RETRO_DOMAIN, scanForSetup, buildSetupPlan, scaffoldFromSpec, renderScaffoldPreview, readExistingForScaffold, assembleChallengeContext, buildChallengeBrief, planDiscriminationCheck, classifyDiscrimination, pickAdversaryModel, CHALLENGE_QUESTIONS, loadOutcomes, renderOutcomes, statsForKey, selectAutoCost, recordProvisional, finalizeOutcome, COST_LADDER, splitScenarios, budgetPlan, selectWinner, proseScopeOk, renderProseDiff, readScenarioIds, DEFAULT_MAX_JUDGE_RUNS, } from '@dzhechkov/harness-core';
 import { getPreset, PRESET_NAMES } from '@dzhechkov/harness-presets';
 import { scanGitHub, analyzeRepo, generateReport, deepAnalyze, scanAllSources, ScoutMemory } from '@dzhechkov/scout';
 const USAGE = `dz - DZ cross-platform harness CLI
@@ -32,6 +32,7 @@ Usage:
   dz sign   --pack <dir> --key <path-outside-repo>          (Ed25519 manifest + CycloneDX SBOM for a pack)
   dz verify-pack --pack <dir> [--pubkey <path>]             (signature check; fail-closed; key from the repo, never the pack)
   dz publish [--filter <name>] [--bump-only] [--claim-check <off|warn|error>] [--require-signing] [--provenance|--no-provenance]   (dry-run by default; pass --yes/--confirm/--no-dry-run to go live; claim-check gate default warn — surfaces README claim findings, never blocks; error fails an offending package)
+  dz release [--filter <name>] [--tag] [--publish] [--json] [--dry-run] [--no-issue]   (VERIFIED release: 4 HARD gates in FRONT of dz publish — full package test suites, audit >=high, node --check of every dist/bin file, bin smoke-boot via "node <bin> --help" — any red gate STOPS the release (exit 1) + best-effort gh issue; all green ⇒ re-sign reminder, then prints the ready dz publish command (or chains with --publish); never duplicates publish's own gates)
   dz setup --target <name> [--preset <name>] [--select id,id,...] [--skills-dir <dir>] [--project <dir>] [--memory agentdb] [--no-memory] [--no-hooks] [--install-driver] [--force] [--enrich]
   dz teach "<pattern>" [--reward <0-1>] [--domain <name>] [--type rule|success-pattern|lesson-learned] [--project <dir>] [--no-mirror]   (--project pins the learned store to <dir>/.dz, not the cwd — pin to a canonical brain)
   dz teach --from-json <file> [--project <dir>] [--no-mirror]   (bulk-import a 'dz recall --all --json' export — share a learned store across machines)
@@ -2784,25 +2785,9 @@ async function cmdAutoCanonicalize(options, cwd, write) {
 }
 /** The pinned trust root. A key inside the artifact under verification is data, not a key (ADR-001). */
 const TRUST_ROOT_REL = 'keys/dz.pub';
-function packFiles(dir) {
-    const out = [];
-    const walk = (d, rel) => {
-        for (const e of readdirSync(d, { withFileTypes: true })) {
-            if (e.name === 'node_modules' || e.name === '.git')
-                continue;
-            if (e.name === MANIFEST_NAME || e.name === SBOM_NAME)
-                continue;
-            const abs = join(d, e.name);
-            const r = rel ? rel + '/' + e.name : e.name;
-            if (e.isDirectory())
-                walk(abs, r);
-            else if (e.isFile())
-                out.push(r);
-        }
-    };
-    walk(dir, '');
-    return out.sort();
-}
+// One walk to rule both: the SIGN file list is core's listPackFiles — the SAME function verify uses for
+// its added-file sweep, so the two can never drift apart again (the 10-false-TAMPERED lesson, task #36).
+const packFiles = (dir) => listSignablePackFiles(dir);
 /**
  * The consumer-side apply-leg (ADR-001, verify-apply-leg). All security content lives in the two pure
  * functions in harness-core; this only resolves paths, reads bytes, and reports.
@@ -3276,6 +3261,308 @@ function cmdPublish(options, flags, cwd, write) {
     }
     return report.errors > 0 ? 1 : 0;
 }
+/* ------------------------------------------------------------------ */
+/*  dz release — verified-release conveyor (feature release-verified,  */
+/*  ADR-001): 4 HARD gates in FRONT of the untouched dz publish.       */
+/* ------------------------------------------------------------------ */
+/**
+ * The single executor of the pure engine's {@link GateStep} plan. ALL subprocess side effects
+ * of the release live here (engine purity, NFR-1). Contract highlights:
+ *
+ * - ALL four gates execute even after an earlier gate fails (AM-9/FR-6 — no fail-fast hiding);
+ *   one red gate still reddens the release.
+ * - Smoke steps run in a THROWAWAY cwd (AM-4): skills bins are installers that mutate
+ *   `.claude/` on default action.
+ * - gh issue + git tag are best-effort periphery: loud on failure, NEVER verdict- or
+ *   exit-code-affecting (FR-7/FR-8, AM-6).
+ * - On green it never injects `--yes/--confirm/--no-dry-run` into the printed/chained publish
+ *   (AM-5): live publish stays the operator's explicit act, and `--publish` chains into
+ *   publish's own default (dry-run) protocol with ALL its gates untouched.
+ */
+function cmdRelease(options, flags, cwd, write, runner) {
+    const json = flags.has('json');
+    const warnings = [];
+    const say = (line) => {
+        if (!json)
+            write(line);
+    };
+    const loud = (line) => {
+        warnings.push(line);
+        if (!json)
+            write(line);
+    };
+    const emitJson = (obj) => {
+        if (json)
+            write(JSON.stringify({ ...obj, warnings }, null, 2));
+    };
+    // G9 reuse-never-copy: the engine's firstOutputLine, not a byte-parallel local copy.
+    const oneLine = firstOutputLine;
+    // Strict allowlist (cmdPublish's typo-rejection pattern) — a mistyped flag is NEVER
+    // swallowed, and the rejection honors the --json contract too (AC-7).
+    // `--verified` is accepted but not read: verified is the DEFAULT and only mode of
+    // `dz release` in this slice — the flag exists so the branded invocation is not a typo error.
+    const allowedFlags = new Set(['verified', 'tag', 'publish', 'json', 'dry-run', 'no-issue', 'affected', 'audit-dev', 'help']);
+    const allowedOptions = new Set(['filter']);
+    const allowedHelp = '  allowed: --verified, --filter <substr>, --affected, --audit-dev, --tag, --publish, --json, --dry-run, --no-issue';
+    const rejectUnknown = (key) => {
+        if (json)
+            write(JSON.stringify({ error: `unknown option --${key}`, allowed: allowedHelp.trim(), publishAction: 'blocked', exitCode: 1 }, null, 2));
+        else {
+            write(`dz release: unknown option --${key}`);
+            write(allowedHelp);
+        }
+        return 1;
+    };
+    for (const flag of flags)
+        if (!allowedFlags.has(flag))
+            return rejectUnknown(flag);
+    for (const key of options.keys()) {
+        if (key.startsWith('_positional_'))
+            continue;
+        if (!allowedOptions.has(key))
+            return rejectUnknown(key);
+    }
+    // --filter mirrors publish semantics: trim + drop empties; empty result is an ERROR,
+    // never "match all" (the publish P0 regression this deliberately copies).
+    const filterStr = options.get('filter');
+    let filter;
+    if (filterStr !== undefined) {
+        filter = filterStr.split(',').map((s) => s.trim()).filter((s) => s.length > 0);
+        if (filter.length === 0) {
+            if (json)
+                write(JSON.stringify({ error: '--filter requires a non-empty comma-separated list of package-name substrings', publishAction: 'blocked', exitCode: 1 }, null, 2));
+            else
+                write('dz release: --filter requires a non-empty comma-separated list of package-name substrings');
+            return 1;
+        }
+    }
+    // DETECT — real facts via the engine's one fs seam (discoverPackages underneath).
+    let factsList;
+    try {
+        factsList = collectPackageFacts(cwd, filter);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (json)
+            write(JSON.stringify({ error: msg, publishAction: 'blocked', exitCode: 1 }, null, 2));
+        else
+            write(`dz release: ${msg}`);
+        return 1;
+    }
+    if (factsList.length === 0) {
+        // C-6: outside a workspace (or an over-narrow filter) — explain and exit non-zero, never throw.
+        const msg = 'no publishable packages found under packages/@dzhechkov — run from the monorepo root (or widen --filter)';
+        if (json)
+            write(JSON.stringify({ error: msg, packages: [], publishAction: 'blocked', exitCode: 1 }, null, 2));
+        else
+            write(`dz release: ${msg}`);
+        return 1;
+    }
+    // Executor: default = real execSync with piped stdio + timeout; injectable for tests.
+    // Defined BEFORE planning because --affected needs read-only git diffs at DETECT time.
+    const run = runner ??
+        ((cmd, opts) => {
+            try {
+                const stdout = execSync(cmd, { cwd: opts.cwd, stdio: 'pipe', encoding: 'utf-8', timeout: opts.timeoutMs });
+                return { exitCode: 0, stdout: stdout == null ? '' : String(stdout), stderr: '' };
+            }
+            catch (err) {
+                const e = err;
+                // execSync's timeout kills via signal and leaves status null — that IS the timeout shape.
+                const timedOut = (e.status === null || e.status === undefined) && (e.signal != null || e.killed === true);
+                return {
+                    exitCode: typeof e.status === 'number' ? e.status : 1,
+                    stdout: e.stdout == null ? '' : String(e.stdout),
+                    stderr: e.stderr == null || String(e.stderr).trim() === '' ? formatPublishError(e) : String(e.stderr),
+                    timedOut,
+                };
+            }
+        });
+    // AM-8/--affected: narrow the release set to packages touched by the working tree + last
+    // commit. Selection is the PURE selectAffectedPackages; the two read-only git diffs are the
+    // injected fact source. Any git failure ⇒ null ⇒ FAIL-OPEN to the full set (never zero).
+    if (flags.has('affected')) {
+        const dWork = run('git diff --name-only HEAD', { cwd, timeoutMs: 10_000 });
+        const dLast = run('git diff --name-only HEAD~1..HEAD', { cwd, timeoutMs: 10_000 });
+        const anyOk = dWork.exitCode === 0 || dLast.exitCode === 0;
+        const changed = anyOk
+            ? [dWork, dLast]
+                .filter((r) => r.exitCode === 0)
+                .flatMap((r) => r.stdout.split('\n'))
+                .map((s) => s.trim())
+                .filter((s) => s.length > 0)
+            : null;
+        const selected = selectAffectedPackages(changed, factsList);
+        if (changed === null)
+            loud('dz release --affected: ⚠ git diff unavailable — FAIL-OPEN to the full package set');
+        else
+            say(`dz release --affected: ${selected.length}/${factsList.length} package(s) selected from ${changed.length} changed file(s)${selected.length === factsList.length ? ' (no narrowing — full set)' : ''}`);
+        factsList = selected;
+    }
+    const plan = planReleaseGates(factsList, {
+        monorepoRoot: cwd,
+        pnpmLockPresent: existsSync(join(cwd, 'pnpm-lock.yaml')),
+        includeDevDeps: flags.has('audit-dev'),
+    });
+    // --dry-run: print the full plan, execute NOTHING (deterministic, byte-testable preview).
+    if (flags.has('dry-run')) {
+        if (json) {
+            write(JSON.stringify({ dryRun: true, packages: plan.packages, steps: plan.steps, skips: plan.skips, warnings }, null, 2));
+            return 0;
+        }
+        write(`\ndz release --dry-run — plan only, zero commands executed (${plan.packages.length} package(s))`);
+        for (const gate of ['tests', 'audit', 'syntax', 'smoke']) {
+            const steps = plan.steps.filter((s) => s.gate === gate);
+            write(`  ${gate} (${steps.length} step(s)):`);
+            for (const s of steps) {
+                if (s.kind === 'synthetic-fail')
+                    write(`    ✗ [planned ${s.failClass ?? 'FAIL'}] ${s.pkg ?? ''}: ${s.reason}`);
+                else
+                    write(`    · ${s.cmd}  (cwd=${s.tempCwd === true ? '<temp>' : s.cwd}, timeout=${s.timeoutMs}ms)`);
+            }
+            if (gate === 'tests')
+                for (const sk of plan.skips)
+                    write(`    ○ [${sk.class}] ${sk.pkg}: ${sk.reason}`);
+        }
+        write('  → run without --dry-run to execute the gates');
+        return 0;
+    }
+    // VERIFY — execute EVERY exec step (AM-9: all 4 gates run and report even after a failure).
+    const executions = [];
+    let smokeTmp;
+    const execSteps = plan.steps.filter((s) => s.kind !== 'synthetic-fail');
+    say(`\ndz release — executing ${execSteps.length} gate step(s) across ${plan.packages.length} package(s)…`);
+    for (const step of execSteps) {
+        let stepCwd = step.cwd;
+        if (step.tempCwd === true) {
+            // AM-4: boot bins in a throwaway cwd so an installer-style bin cannot mutate the workspace.
+            if (smokeTmp === undefined)
+                smokeTmp = mkdtempSync(join(tmpdir(), 'dz-release-smoke-'));
+            stepCwd = smokeTmp;
+        }
+        const started = Date.now();
+        const r = run(step.cmd, { cwd: stepCwd, timeoutMs: step.timeoutMs });
+        executions.push({
+            stepId: step.id,
+            exitCode: r.exitCode,
+            stdout: r.stdout,
+            stderr: r.stderr,
+            durationMs: Date.now() - started,
+            timedOut: r.timedOut,
+        });
+    }
+    if (smokeTmp !== undefined) {
+        try {
+            rmSync(smokeTmp, { recursive: true, force: true });
+        }
+        catch { /* best-effort cleanup */ }
+    }
+    const verdict = classifyGateExecutions(plan, executions);
+    // Report: per-gate ✓/✗/○ with package granularity + timestamp (NFR-5). Skips are named,
+    // never folded into pass wording (AM-2: "N passed, M skipped", not "all tests passed").
+    for (const g of verdict.gates) {
+        const icon = g.status === 'pass' ? '✓' : g.status === 'fail' ? '✗' : '○';
+        say(`  ${icon} ${g.gate.padEnd(7)} ${g.status.toUpperCase().padEnd(4)}  ${g.passed} passed, ${g.failures.length} failed, ${g.skips.length} skipped`);
+        for (const f of g.failures)
+            say(`      [${f.class}] ${f.pkg !== undefined ? `${f.pkg}: ` : ''}${f.reason}`);
+        for (const sk of g.skips)
+            say(`      [${sk.class}] ${sk.pkg}: ${sk.reason}`);
+    }
+    say(`  verdict at ${verdict.timestamp}: ${verdict.publishAction === 'proceed' ? '✓ all gates green' : '✗ RELEASE BLOCKED'}`);
+    const invocation = `dz release${filterStr !== undefined ? ` --filter ${filterStr}` : ''}`;
+    const shq = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
+    if (verdict.publishAction === 'blocked') {
+        say(`dz release: ✗ release STOPPED — ${verdict.blockedBy.join('; ')}`);
+        // FR-7 / AM-6: best-effort issue — a courier, never a judge. Loud on any failure;
+        // the verdict and exit code are ALREADY decided and cannot change here.
+        let issueUrl;
+        if (!flags.has('no-issue')) {
+            const issue = buildFailureIssue(verdict, { invocation });
+            const probe = run('command -v gh', { cwd, timeoutMs: 10_000 });
+            if (probe.exitCode !== 0) {
+                loud(`dz release: ⚠ gh unavailable — file the issue manually: ${issue.title}`);
+            }
+            else {
+                const res = run(`gh issue create --title ${shq(issue.title)} --body ${shq(issue.body)}`, { cwd, timeoutMs: 30_000 });
+                if (res.exitCode === 0) {
+                    issueUrl = oneLine(res.stdout) || undefined;
+                    say(`dz release: gh issue created${issueUrl !== undefined ? `: ${issueUrl}` : ''}`);
+                }
+                else {
+                    loud(`dz release: ⚠ gh issue creation failed (${oneLine(res.stderr, res.stdout) || 'unknown error'}) — file the issue manually: ${issue.title}`);
+                }
+            }
+        }
+        emitJson({
+            gates: verdict.gates,
+            ok: verdict.ok,
+            blockedBy: verdict.blockedBy,
+            skipped: verdict.skipped,
+            publishAction: verdict.publishAction,
+            timestamp: verdict.timestamp,
+            ...(issueUrl !== undefined ? { issueUrl } : {}),
+            exitCode: 1,
+        });
+        return 1;
+    }
+    // Success path. FR-8: --tag is best-effort trimming — loud on failure, never gate-affecting.
+    let tagName;
+    if (flags.has('tag')) {
+        const sha = run('git rev-parse --short HEAD', { cwd, timeoutMs: 10_000 });
+        const log = run('git log --oneline -n 15 --no-decorate', { cwd, timeoutMs: 10_000 });
+        const notes = buildReleaseNotes(log.exitCode === 0 ? log.stdout.split('\n') : []);
+        tagName = releaseTagName(new Date(), sha.exitCode === 0 ? sha.stdout.trim() : '');
+        const tag = run(`git tag -a ${tagName} -m ${shq(notes)}`, { cwd, timeoutMs: 10_000 });
+        if (tag.exitCode === 0) {
+            say(`dz release: tagged ${tagName} (annotated with short release notes from recent commits)`);
+            say('dz release: note — the tag attests a VERIFIED tree, not a completed publish');
+        }
+        else {
+            loud(`dz release: ⚠ git tag failed (${oneLine(tag.stderr, tag.stdout) || 'unknown error'}) — non-blocking; tag manually: git tag -a ${tagName}`);
+        }
+    }
+    // FR-10 / AC-8: re-sign reminder BEFORE the handoff — publish's signature gate is
+    // refuse-unsigned, and gates 3–4 often follow a rebuild.
+    say('dz release: reminder — re-sign any rebuilt packs BEFORE publishing (dz sign --pack <dir> --key <path-outside-repo>); the publish signature gate is refuse-unsigned');
+    // FR-9 / AM-5: the handoff NEVER injects --yes/--confirm/--no-dry-run — live publish stays
+    // the operator's explicit, loud-bannered act inside dz publish itself.
+    const publishCommand = `dz publish${filterStr !== undefined ? ` --filter ${filterStr}` : ''}`;
+    let publishExit;
+    let publishOutput;
+    if (flags.has('publish')) {
+        say(`dz release: ✓ gates green — chaining into ${publishCommand} in-process (ALL publish gates + its dry-run-by-default protocol run untouched)`);
+        const pubOptions = new Map(filterStr !== undefined ? [['filter', filterStr]] : []);
+        // --json contract: the chained publish must NOT print prose before the JSON envelope —
+        // capture its lines and carry them INSIDE the envelope instead (stdout stays one JSON doc).
+        if (json) {
+            publishOutput = [];
+            const captured = publishOutput;
+            publishExit = cmdPublish(pubOptions, new Set(), cwd, (line) => {
+                captured.push(line);
+            });
+        }
+        else {
+            publishExit = cmdPublish(pubOptions, new Set(), cwd, write);
+        }
+    }
+    else {
+        say(`dz release: ✓ all gates green — publish when ready: ${publishCommand}`);
+    }
+    emitJson({
+        gates: verdict.gates,
+        ok: verdict.ok,
+        blockedBy: verdict.blockedBy,
+        skipped: verdict.skipped,
+        publishAction: verdict.publishAction,
+        timestamp: verdict.timestamp,
+        ...(tagName !== undefined ? { tag: tagName } : {}),
+        publishCommand,
+        ...(publishExit !== undefined ? { publishExit } : {}),
+        ...(publishOutput !== undefined ? { publishOutput } : {}),
+        exitCode: publishExit ?? 0,
+    });
+    return publishExit ?? 0;
+}
 function cmdRegistry(options, cwd, write) {
     const registry = buildRegistry(cwd);
     if (registry.totalSkills === 0) {
@@ -5203,6 +5490,8 @@ export async function runCli(argv, io = {}) {
                 return await cmdAutoCanonicalize(options, cwd, write);
             case 'publish':
                 return cmdPublish(options, flags, cwd, write);
+            case 'release':
+                return cmdRelease(options, flags, cwd, write, io.releaseRunner);
             case 'registry':
                 return cmdRegistry(options, cwd, write);
             case 'benchmark':