@dzhechkov/harness-cli 0.8.19 → 0.8.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/harness-cli",
-  "version": "0.8.19",
+  "version": "0.8.21",
   "description": "The dz CLI — install AI skills for Claude Code, Codex, OpenCode, Hermes, OpenClaude, GitHub Copilot. 87 commands, 14 presets, 10 platform targets.",
   "type": "module",
   "license": "MIT",
@@ -42,23 +42,23 @@
     "src"
   ],
   "dependencies": {
-    "@dzhechkov/harness-core": "^0.8.27",
+    "@dzhechkov/harness-core": "^0.8.29",
     "@dzhechkov/harness-presets": "^0.5.18",
-    "@dzhechkov/skills-devops": "^0.3.17",
-    "@dzhechkov/scout": "^0.8.11",
     "@dzhechkov/skills-mcp": "^0.3.10",
+    "@dzhechkov/scout": "^0.8.11",
+    "@dzhechkov/skills-devops": "^0.3.17",
     "@dzhechkov/skills-web3": "^0.2.9",
     "@dzhechkov/skills-meta": "^0.9.55",
-    "@dzhechkov/skills-academic": "^0.3.7",
     "@dzhechkov/skills-qe": "^0.3.14",
-    "@dzhechkov/skills-news": "^0.1.16",
+    "@dzhechkov/skills-academic": "^0.3.7",
     "@dzhechkov/skills-ecc": "^0.1.12",
+    "@dzhechkov/skills-news": "^0.1.16",
     "@dzhechkov/skills-pm": "^0.1.5",
     "@dzhechkov/skills-taste": "^0.1.5",
     "@dzhechkov/skills-idea2prd": "^0.1.15",
     "@dzhechkov/skills-reverse-engineering": "^0.3.4",
-    "@dzhechkov/skills-website-cloner": "^0.1.5",
-    "@dzhechkov/skills-presentation-storyteller": "^0.1.14"
+    "@dzhechkov/skills-presentation-storyteller": "^0.1.14",
+    "@dzhechkov/skills-website-cloner": "^0.1.5"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",
@@ -73,7 +73,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/djd1m/dz-harness.git",
+    "url": "git+https://github.com/djd1m/dz-harness-hub.git",
     "directory": "packages/@dzhechkov/harness-cli"
   },
   "homepage": "https://github.com/djd1m/dz-harness/tree/main/packages/@dzhechkov/harness-cli#readme",

package/sbom.json

@@ -25,7 +25,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "45af5a47278e24f2049789ac96bba2c18597e29e26f3a9df3ac95fc5b52719c2"
+          "content": "2a3c1e1f9f922913c45df3482f2055ac2efc726108e1d4377195739e026a4034"
         }
       ]
     },
@@ -125,7 +125,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "22cddd1ff809cea9301af0905195bc1f2ff29730ce1b8a257c99c518457cff34"
+          "content": "ef3852bb748f37d4e78a9a973505c3993eae2b996cc0cdd0659f531aa76621f4"
         }
       ]
     },
@@ -135,7 +135,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "724695fafaa2a68b6c279ea1f55f14732888ee7ba6919f991ace14fa54620b08"
+          "content": "9d0a6cc044810b31d261b36913e3f63445f5e96550176fedd0faf606d8cbcd75"
         }
       ]
     },
@@ -145,7 +145,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "2935abfc89e4a704d9615b0417ff19279487c05a8a97347b2de6c88908276d33"
+          "content": "3049258ffd0972b6a748eda703221911dd33e3450486c1dec0f598a431faa038"
         }
       ]
     },
@@ -379,7 +379,7 @@
         },
         {
           "name": "dz:canonical-json-sha256-v2",
-          "value": "5f0c597e704b7b515d40f4a95b784b26d4fe2a5adf1f1309a350541506eb14d4"
+          "value": "52e0e71990b14cf8dc5b07046c30d6d9807f7cec1cdef4463ac6bd155b0312d4"
         }
       ]
     },
@@ -409,7 +409,7 @@
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "f0bc9f52737064a3d5b26fb2ef07c0aa79e003dfca5e1277cd0988a65cdeeb8e"
+          "content": "f34208b28b53697118db5370f82c6aaab883bb7be10d99789a96a39a06acfac7"
         }
       ]
     },

package/src/cli.ts

@@ -279,6 +279,8 @@ import {
   isInsideTree,
   signManifest,
   verifyManifest,
+  hashPackBytes,
+  rewriteWorkspaceSpecs,
   listPackFiles,
   listSignablePackFiles,
   assertKeyOutsideTree,
@@ -7177,6 +7179,8 @@ function cmdPublish(options: Map<string, string>, flags: Set<string>, cwd: strin
       for (const item of pkg.notVerified) write(`         · ${item}`);
     }
   }
+  for (const warning of report.warnings ?? []) write(`  ⚠ warning: ${warning}`);
+  for (const path of report.releaseLineSynced ?? []) write(`  ↳ release line synced: ${path}`);
   return report.errors > 0 ? 1 : 0;
 }
 
@@ -9635,21 +9639,52 @@ function gatherGuardFacts(op: string, root: string, text: string | undefined, st
     // a resolvable workspace dep becomes its real semver (safe → the rule passes); an UNRESOLVABLE one (points at
     // no workspace package, or not a pnpm workspace) stays `workspace:*` so the rule catches a dep that WOULD ship
     // raw. That is the genuinely dangerous case the rule exists for.
-    type Manifest = { name?: string; version?: string; private?: boolean; license?: string; licenseHold?: unknown; dependencies?: Record<string, string>; devDependencies?: Record<string, string> };
+    type Manifest = { name?: string; version?: string; private?: boolean; license?: string; licenseHold?: unknown; dependencies?: Record<string, string>; devDependencies?: Record<string, string>; peerDependencies?: Record<string, string>; optionalDependencies?: Record<string, string> };
     const manifests: Manifest[] = [];
-    const located: { dir: string; m: Manifest }[] = [];
+    const located: { dir: string; m: Manifest; text: string }[] = [];
     try {
       const out = volumeGitText(root, ['ls-files', 'packages/@dzhechkov/*/package.json']);
       for (const rel of out.split('\n').map((s) => s.trim()).filter(Boolean)) {
         try {
-          const m = JSON.parse(readFileSync(join(root, rel), 'utf8')) as Manifest;
+          const packageJsonText = readFileSync(join(root, rel), 'utf8');
+          const m = JSON.parse(packageJsonText) as Manifest;
           manifests.push(m);
-          located.push({ dir: rel.replace(/\/package\.json$/, ''), m });
+          located.push({ dir: rel.replace(/\/package\.json$/, ''), m, text: packageJsonText });
         } catch { /* skip unreadable */ }
       }
     } catch { /* not a git repo */ }
     const versionByName = new Map<string, string>();
     for (const m of manifests) if (m.name && typeof m.version === 'string') versionByName.set(m.name, m.version);
+    // release-line-in-sync: filesystem access belongs in the CLI gatherer. The core evaluator receives
+    // only immutable evidence, so evaluateGuard(facts) stays deterministic and independent of cwd.
+    const coreManifestPath = join(root, 'packages', '@dzhechkov', 'harness-core', 'package.json');
+    const cliManifestPath = join(root, 'packages', '@dzhechkov', 'harness-cli', 'package.json');
+    if (existsSync(coreManifestPath) || existsSync(cliManifestPath)) {
+      const readText = (path: string): string | null => {
+        try { return readFileSync(path, 'utf8'); } catch { return null; }
+      };
+      const readVersion = (path: string): string | null => {
+        const raw = readText(path);
+        if (raw === null) return null;
+        try {
+          const parsed = JSON.parse(raw) as { version?: unknown };
+          return typeof parsed.version === 'string' && /^\d+\.\d+\.\d+$/.test(parsed.version)
+            ? parsed.version
+            : null;
+        } catch { return null; }
+      };
+      facts['releaseLines'] = {
+        coreVersion: readVersion(coreManifestPath),
+        cliVersion: readVersion(cliManifestPath),
+        readmes: [
+          { path: 'README.md', text: readText(join(root, 'README.md')) },
+          {
+            path: 'packages/@dzhechkov/harness-cli/README.md',
+            text: readText(join(root, 'packages', '@dzhechkov', 'harness-cli', 'README.md')),
+          },
+        ],
+      };
+    }
     publishPackageRoots.push(...located
       .filter(({ dir, m }) => m.private !== true && (
         publishFilter === undefined
@@ -9811,22 +9846,136 @@ function gatherGuardFacts(op: string, root: string, text: string | undefined, st
       }
     } catch { /* нечитаемо — правило молчит */ }
     facts['counts'] = gatherReadmeCounts(root);
-    // readme-first: from the WORKING-TREE diff (publishes happen pre-commit here), per package: does the
-    // change set contain its package.json (the version-bump signal) without its README.md?
+    // One package-scoped WORKING-TREE diff feeds both readme-first and signature-fresh. A second
+    // porcelain call could observe a different tree and let the two publish guards disagree.
+    let changedPackageFiles: string[] | undefined;
+    // readme-first: from the WORKING-TREE diff (publishes happen pre-commit here), per package: did
+    // the version FIELD change from HEAD without its README.md changing? A package.json edit alone
+    // says nothing about version; repository/metadata-only edits must not manufacture a bump.
     try {
-      const status = execSync('git status --porcelain -- "packages/@dzhechkov/"', { cwd: root, encoding: 'utf-8' });
-      const perPack = new Map<string, { pkgJson: boolean; readme: boolean }>();
-      for (const line of status.split('\n')) {
-        const m = line.match(/packages\/@dzhechkov\/([^/]+)\/(.+)$/);
+      const status = execSync('git status --porcelain -uall -- "packages/@dzhechkov/"', { cwd: root, encoding: 'utf-8' });
+      changedPackageFiles = status
+        .split('\n')
+        .map((line) => line.slice(3).trim())
+        .map((path) => (path.includes(' -> ') ? path.split(' -> ')[1]!.trim() : path))
+        .filter(Boolean);
+      const perPack = new Map<string, { readme: boolean }>();
+      for (const rel of changedPackageFiles) {
+        const m = rel.match(/^packages\/@dzhechkov\/([^/]+)\/(.+)$/);
         if (!m || !m[1] || !m[2]) continue;
-        const e = perPack.get(m[1]) ?? { pkgJson: false, readme: false };
-        if (m[2] === 'package.json') e.pkgJson = true;
+        const e = perPack.get(m[1]) ?? { readme: false };
         if (m[2] === 'README.md') e.readme = true;
         perPack.set(m[1], e);
       }
-      facts['readmeFirst'] = [...perPack.entries()].map(([name, e]) => ({ name: '@dzhechkov/' + name, versionBumped: e.pkgJson, readmeChanged: e.readme }));
+      const readVersion = (raw: string): string => {
+        const version = (JSON.parse(raw) as { version?: unknown }).version;
+        if (typeof version !== 'string') throw new Error('package version is unreadable');
+        return version;
+      };
+      facts['readmeFirst'] = [...perPack.entries()].map(([name, e]) => {
+        const packagePath = `packages/@dzhechkov/${name}/package.json`;
+        let versionBumped = false;
+        let versionUnknown = false;
+        try {
+          const treeVersion = readVersion(readFileSync(join(root, packagePath), 'utf8'));
+          try {
+            const headVersion = readVersion(execFileSync('git', ['show', `HEAD:${packagePath}`], {
+              cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'],
+            }));
+            versionBumped = treeVersion !== headVersion;
+          } catch {
+            try {
+              const trackedAtHead = execFileSync('git', ['ls-tree', '--name-only', 'HEAD', '--', packagePath], {
+                cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'],
+              }).trim() === packagePath;
+              if (trackedAtHead) versionUnknown = true;
+              else versionBumped = true;
+            } catch {
+              versionUnknown = true;
+            }
+          }
+        } catch {
+          versionUnknown = true;
+        }
+        return {
+          name: '@dzhechkov/' + name,
+          versionBumped,
+          readmeChanged: e.readme,
+          ...(versionUnknown ? { versionUnknown: true } : {}),
+        };
+      });
     } catch { /* not a git repo — rule skips */ }
 
+    // signature-fresh: verify only signed packs whose non-signature files changed in the same
+    // porcelain listing above. Manifest/SBOM churn is the remedy, not another reason to verify.
+    // The trust key and every byte read here stay in the CLI; the guard core receives facts only.
+    const trustRootPath = join(root, TRUST_ROOT_REL);
+    if (changedPackageFiles !== undefined && existsSync(trustRootPath)) {
+      try {
+        const trustRootPem = readFileSync(trustRootPath, 'utf8');
+        const signedPacks: {
+          name: string;
+          dir: string;
+          changed: boolean;
+          ok: boolean | null;
+          failures: string[];
+          note?: string;
+        }[] = [];
+        for (const { dir, m, text: packageJsonText } of located) {
+          const manifestPath = join(root, dir, MANIFEST_NAME);
+          if (!existsSync(manifestPath)) continue;
+          const prefix = dir + '/';
+          const changedPackFiles = new Set(changedPackageFiles
+            .filter((rel) => rel.startsWith(prefix))
+            .map((rel) => rel.slice(prefix.length))
+            .filter((packRel) => packRel !== MANIFEST_NAME && packRel !== SBOM_NAME));
+          const changed = changedPackFiles.size > 0;
+          let ok: boolean | null = null;
+          let failures: string[] = [];
+          let note: string | undefined;
+          if (changed) {
+            try {
+              const signed = JSON.parse(readFileSync(manifestPath, 'utf8')) as {
+                manifest?: { files?: readonly { path?: unknown; sha256?: unknown }[] };
+              };
+              const verified = verifyManifest(join(root, dir), signed as never, trustRootPem);
+              // A source checkout contains dev files outside package.json#files. They are absent
+              // from the tarball by design, so an unchanged "present but not signed" source file
+              // is not evidence about signature freshness. A changed/new unsigned file stays loud.
+              const relevantFailures = verified.failures.filter((failure) =>
+                failure.reason !== 'present in the pack but not signed' || changedPackFiles.has(failure.path));
+              ok = verified.ok || relevantFailures.length === 0;
+              if (!ok && relevantFailures.length > 0 && relevantFailures.every(({ path }) => path === 'package.json')) {
+                const signedPackageHash = signed.manifest?.files?.find(({ path }) => path === 'package.json')?.sha256;
+                if (typeof signedPackageHash === 'string') {
+                  const rewritten = rewriteWorkspaceSpecs(packageJsonText, versionByName);
+                  // MEASURED 2026-09-10 on keysarium/skills-meta/core: pnpm also removes only
+                  // prepublishOnly from the packed scripts table. Keep that I/O-adapter concern
+                  // outside the workspace-only core helper.
+                  const packedShape = JSON.parse(rewritten) as Record<string, unknown>;
+                  const scripts = packedShape['scripts'];
+                  if (scripts !== null && typeof scripts === 'object' && !Array.isArray(scripts)) {
+                    delete (scripts as Record<string, unknown>)['prepublishOnly'];
+                  }
+                  const rewrittenHash = hashPackBytes('package.json', Buffer.from(JSON.stringify(packedShape, null, 2) + '\n'), (signed.manifest as { version?: number } | undefined)?.version);
+                  if (rewrittenHash === signedPackageHash) {
+                    ok = true;
+                    note = 'package.json matches after workspace rewrite';
+                  }
+                }
+              }
+              failures = relevantFailures.slice(0, 3).map((failure) => `${failure.path}: ${failure.reason}`);
+            } catch (error) {
+              ok = false;
+              failures = [`${MANIFEST_NAME}: ${error instanceof Error ? error.message : String(error)}`];
+            }
+          }
+          signedPacks.push({ name: m.name ?? dir, dir, changed, ok, failures, ...(note !== undefined ? { note } : {}) });
+        }
+        facts['signedPacks'] = signedPacks;
+      } catch { /* unreadable trust root — absence of evidence, so the rule is not established */ }
+    }
+
     // review-round: the same WORKING-TREE diff, asked a different question — does a package that
     // bumps its version and changes SOURCE bring a GRADED QE report with it? Scoped to source so a
     // docs-only republish is never blocked (ADR-001, features/publish-needs-a-review). A throw here