@dzhechkov/harness-core 0.8.32 → 0.8.33

package/src/publish.ts

@@ -14,9 +14,15 @@ import { execSync } from 'node:child_process';
 // Structural twin of node's ExecSyncOptionsWithStringEncoding — a type-only import of node:child_process
 // still counts as an IO import for the core-boundary ratchet (measured 66 → 67), so the shape is spelled here.
 type ExecSyncOptionsWithStringEncoding = NonNullable<Parameters<typeof execSync>[1]> & { encoding: 'utf-8' };
+// node:crypto is NOT in the core-boundary ratchet's tracked module list (fs/child_process/https
+// only) — a read-only digest of bytes already produced by THIS process is not the kind of external
+// I/O the ratchet polices, so this import is free with respect to it (verified against
+// `core-boundary.ts`'s `countIoImports` module list).
+import { createHash } from 'node:crypto';
 
 import { claimCheck } from './claim-check.js';
 import { rewriteReleaseLine } from './release-line.js';
+import { packedTarballName } from './packed-install-smoke.js';
 
 export type ProbeOutcome = {
   readonly attempt: number;
@@ -59,6 +65,32 @@ export interface PublishResult {
    * and the CLI prints it. Absent on a real publish, where every gate actually ran.
    */
   readonly notVerified?: readonly string[] | undefined;
+  /**
+   * AM-1 (feature publish-sibling-drift-gate): sha256 of the EXACT tarball bytes that were
+   * packed-install-smoked AND handed to `npm publish` — present only when `opts.packedTransport`
+   * was used for a live (non-dry-run) publish. Printed and audited so "the smoke tested the same
+   * bytes that shipped" is a checkable claim, not an architectural assertion.
+   */
+  readonly sha256?: string | undefined;
+}
+
+/**
+ * One package's packed, smoke-eligible artifact — the unit `opts.packedTransport.smoke` receives
+ * (AM-1). Produced ONCE per package, after its OWN bump/build/sign steps, from a package.json
+ * whose `workspace:` specs are already resolved to each sibling's PINNED version (the same
+ * transformation `rewriteWorkspaceSpecs` performs) — so the tarball is exactly what `npm publish
+ * <tgzPath>` will later ship, byte for byte.
+ */
+export interface PackedTarballArtifact {
+  readonly name: string;
+  readonly newVersion: string;
+  readonly tgzPath: string;
+  readonly sha256: string;
+}
+
+export interface PackedTransportSmokeVerdict {
+  readonly ok: boolean;
+  readonly reason?: string | undefined;
 }
 
 /** Positive read-back evidence returned by the configured public-mirror command. */
@@ -635,6 +667,26 @@ export function publishPackages(
     probe?: ((name: string, version: string) => boolean | Omit<ProbeOutcome, 'attempt'>) | undefined;
     /** Pause injection between receipt probes. The default blocks for the requested milliseconds. */
     sleep?: ((milliseconds: number) => void) | undefined;
+    /**
+     * AM-1 (feature publish-sibling-drift-gate). OPT-IN — omitted (the default), this function is
+     * byte-identical to its pre-amendment self: every package still publishes via `pnpm publish`
+     * FROM ITS DIRECTORY (`publishArgv`), exactly as every existing test of this function expects.
+     *
+     * When provided, the transport for THIS call's batch changes: each package is packed ONCE
+     * (after its own bump/build/sign, workspace: specs resolved to each sibling's PINNED version —
+     * a landed batch sibling's NEW version, an out-of-batch sibling's disk version, mirroring what
+     * `rewriteWorkspaceSpecs`/pnpm itself would resolve), collected, and `smoke` is called with
+     * EVERY package's packed artifact before ANY of them is published. Only on `smoke.ok === true`
+     * does each artifact get `npm publish <tgzPath>` — the exact bytes that were smoked (a sha256
+     * recheck immediately before that call refuses on any mismatch, defending the "same bytes"
+     * claim against anything that could touch the tarball in between).
+     */
+    packedTransport?: {
+      /** Absolute, pre-created directory to write tarballs into (this function never mkdirs it). */
+      readonly packDestDir: string;
+      /** Judge the WHOLE batch's packed artifacts together — nothing publishes until this passes. */
+      readonly smoke: (artifacts: readonly PackedTarballArtifact[]) => PackedTransportSmokeVerdict;
+    } | undefined;
   } = {},
 ): PublishReport {
   // Decide ONCE, before the batch: `--provenance` in an incapable environment must fail here, not on
@@ -665,6 +717,64 @@ export function publishPackages(
   const armFloorPreflight = opts.bumpOnly !== true && (opts.dryRun !== true || opts.probeFloor !== undefined);
   const probeFloor = opts.probeFloor ?? ((name: string, version: string) => probeVersion(name, version).ok);
 
+  // AM-1 (packedTransport): sibling pins for the packing-only rewrite, updated to each package's
+  // NEW version the moment its OWN bump lands — a dependent packed LATER in this same batch must
+  // pin to what its dependency will actually ship, not the stale value captured before the loop
+  // (mirrors what a real `pnpm pack` reads: the dependency's on-disk package.json, already bumped).
+  const pinVersions = new Map(workspaceVersions);
+  interface PendingPacked {
+    readonly name: string;
+    readonly dir: string;
+    readonly oldVersion: string;
+    readonly newVersion: string;
+    readonly tgzPath: string;
+    readonly sha256: string;
+    readonly pkgJsonPath: string;
+    readonly originalPkgJson: string;
+    readonly readmePath: string;
+    readonly originalReadme: string | undefined;
+    readonly claimCheckSummary: { findings: number; high: number } | undefined;
+  }
+  const pendingPacked: PendingPacked[] = [];
+
+  /**
+   * The registry receipt-probe loop, factored out so the packedTransport pass (below) reuses it
+   * identically to the existing per-package publish path — including the "no receipt is not
+   * success" throw itself, so there is exactly ONE place in this file that decides that.
+   */
+  function confirmPublished(name: string, version: string, probeLog: ProbeOutcome[]): { registryProbes: number } {
+    let registryProbes = 0;
+    let confirmed = false;
+    while (registryProbes < REGISTRY_PROBE_BUDGET) {
+      registryProbes++;
+      const probed = probe(name, version);
+      const outcome: Omit<ProbeOutcome, 'attempt'> = typeof probed === 'boolean'
+        ? { ok: probed, stdout: '', stderr: '', code: null, ms: 0 }
+        : probed;
+      probeLog.push({ attempt: registryProbes, ...outcome });
+      if (outcome.ok) {
+        confirmed = true;
+        break;
+      }
+      if (registryProbes < REGISTRY_PROBE_BUDGET) sleep(REGISTRY_PROBE_INTERVAL_MS);
+    }
+    if (!confirmed) {
+      const last = probeLog[probeLog.length - 1]!;
+      const output = last.stderr || last.stdout;
+      const firstLine = output.split(/\r?\n/, 1)[0]?.trim() || '(empty)';
+      throw new Error(
+        `registry did not confirm ${name}@${version} after ${registryProbes} probes ` +
+        `(${Math.round(registryProbes * REGISTRY_PROBE_INTERVAL_MS / 60_000)} min); ` +
+        `last probe: code ${String(last.code)}, ${last.ms}ms, ${firstLine}`,
+      );
+    }
+    return { registryProbes };
+  }
+
+  function sha256File(path: string): string {
+    return createHash('sha256').update(readFileSync(path)).digest('hex');
+  }
+
   for (const pkg of ordered) {
     const oldVersion = pkg.version;
     const pkgJsonPath = join(pkg.dir, 'package.json');
@@ -886,6 +996,60 @@ export function publishPackages(
         }
       }
 
+      if (opts.packedTransport !== undefined) {
+        // AM-1: pack ONCE, from a package.json whose workspace: specs are already resolved to each
+        // sibling's PINNED version — the SAME transformation `rewriteWorkspaceSpecs` performs — so
+        // the tarball about to be smoked is exactly what `npm publish <tgzPath>` ships. Lifecycle
+        // scripts already ran during the `build` step above; `prepublishOnly` is dropped here to
+        // mirror what pnpm itself strips at pack time (the manifest-freshness guard, cli.ts, does
+        // the identical transformation for verification — this is that same convention, now used
+        // to actually PRODUCE the artifact rather than merely check one).
+        const bumpedText = readFileSync(pkgJsonPath, 'utf-8'); // already carries newVersion
+        const rewritten = JSON.parse(rewriteWorkspaceSpecs(bumpedText, pinVersions)) as Record<string, unknown>;
+        const scripts = rewritten['scripts'];
+        if (scripts !== null && typeof scripts === 'object' && !Array.isArray(scripts)) {
+          delete (scripts as Record<string, unknown>)['prepublishOnly'];
+        }
+        const stagedText = JSON.stringify(rewritten, null, 2) + '\n';
+        let tgzPath: string;
+        let digest: string;
+        writeFileSync(pkgJsonPath, stagedText);
+        try {
+          const packOptions = { cwd: pkg.dir, stdio: 'pipe' as const, encoding: 'utf-8' as const };
+          if (opts.exec) opts.exec(`npm pack . --pack-destination ${JSON.stringify(opts.packedTransport.packDestDir)}`, packOptions);
+          else execSync(`npm pack . --pack-destination ${JSON.stringify(opts.packedTransport.packDestDir)}`, packOptions);
+          tgzPath = join(opts.packedTransport.packDestDir, packedTarballName(pkg.name, newVersion));
+          digest = sha256File(tgzPath);
+        } finally {
+          // The COMMITTED tree keeps `workspace:` specs (only the version bump is meant to stick) —
+          // the rewrite above is packing-only and is undone here regardless of pack's outcome.
+          writeFileSync(pkgJsonPath, bumpedText);
+        }
+        pendingPacked.push({
+          name: pkg.name,
+          dir: pkg.dir,
+          oldVersion,
+          newVersion,
+          tgzPath,
+          sha256: digest,
+          pkgJsonPath,
+          originalPkgJson,
+          readmePath: pathJoin(pkg.dir, 'README.md'),
+          originalReadme,
+          claimCheckSummary,
+        });
+        pinVersions.set(pkg.name, newVersion);
+        // Optimistic, mirroring the dry-run branch above: this package WILL land once the
+        // batch-wide smoke (after the loop) passes — a dependent packed later in this same batch
+        // must not re-probe its floor on the registry for an artifact that simply hasn't
+        // published YET (a staged disk version is not a shipped one — but a PACKED one, pending a
+        // batch-wide smoke that the dependent itself is also waiting on, is not "unpublished" in
+        // the sense this preflight polices). Corrected back to `failedInBatch` after the loop if
+        // the smoke actually rejects the batch.
+        landedInBatch.add(pkg.name);
+        continue;
+      }
+
       // Publish
       const publishOptions = {
         cwd: pkg.dir,
@@ -896,31 +1060,7 @@ export function publishPackages(
       if (opts.exec) opts.exec(publishCmd, publishOptions);
       else execSync(publishCmd, publishOptions);
 
-      let registryProbes = 0;
-      let confirmed = false;
-      while (registryProbes < REGISTRY_PROBE_BUDGET) {
-        registryProbes++;
-        const probed = probe(pkg.name, newVersion);
-        const outcome: Omit<ProbeOutcome, 'attempt'> = typeof probed === 'boolean'
-          ? { ok: probed, stdout: '', stderr: '', code: null, ms: 0 }
-          : probed;
-        probeLog.push({ attempt: registryProbes, ...outcome });
-        if (outcome.ok) {
-          confirmed = true;
-          break;
-        }
-        if (registryProbes < REGISTRY_PROBE_BUDGET) sleep(REGISTRY_PROBE_INTERVAL_MS);
-      }
-      if (!confirmed) {
-        const last = probeLog[probeLog.length - 1]!;
-        const output = last.stderr || last.stdout;
-        const firstLine = output.split(/\r?\n/, 1)[0]?.trim() || '(empty)';
-        throw new Error(
-          `registry did not confirm ${pkg.name}@${newVersion} after ${registryProbes} probes ` +
-          `(${Math.round(registryProbes * REGISTRY_PROBE_INTERVAL_MS / 60_000)} min); ` +
-          `last probe: code ${String(last.code)}, ${last.ms}ms, ${firstLine}`,
-        );
-      }
+      const { registryProbes } = confirmPublished(pkg.name, newVersion, probeLog);
 
       results.push({ name: pkg.name, oldVersion, newVersion, status: 'published', registryProbes, probeLog, claimCheck: claimCheckSummary });
       landedInBatch.add(pkg.name); // only an ACTUAL publish covers dependents (Codex P1)
@@ -946,6 +1086,121 @@ export function publishPackages(
     }
   }
 
+  // AM-1 (packedTransport, pass 2): every packable package in the batch has now been bumped,
+  // built, signed and packed into a real tarball — nothing has been published yet. Judge the
+  // WHOLE batch together (the packed-install smoke needs every batch tarball installed at once,
+  // exactly like a fresh user would receive them) BEFORE any of them ships.
+  if (opts.packedTransport !== undefined && pendingPacked.length > 0) {
+    // Lead edit after Codex re-review (finding 1): the transport is ONE transaction — a batch that
+    // lost any package before packing (an earlier error) is never smoked or published partially, and
+    // a smoke that THROWS rolls every pending package back exactly like a failed verdict.
+    const rollbackAll = (reason: string): void => {
+      for (const p of pendingPacked) {
+        try { writeFileSync(p.pkgJsonPath, p.originalPkgJson); } catch { /* best-effort restore */ }
+        if (p.originalReadme !== undefined) {
+          try { writeFileSync(p.readmePath, p.originalReadme); } catch { /* best-effort restore */ }
+        }
+        results.push({
+          name: p.name, oldVersion: p.oldVersion, newVersion: p.newVersion, status: 'error',
+          error: reason, claimCheck: p.claimCheckSummary,
+        });
+        failedInBatch.add(p.name);
+        landedInBatch.delete(p.name);
+      }
+      pendingPacked.length = 0;
+    };
+    if (failedInBatch.size > 0) {
+      rollbackAll(`batch incomplete before smoke (${[...failedInBatch].join(', ')} failed earlier) — nothing published`);
+    }
+    let smokeVerdict: { ok: boolean; reason?: string | undefined } = { ok: false, reason: 'smoke did not run' };
+    if (pendingPacked.length > 0) {
+      try {
+        smokeVerdict = opts.packedTransport.smoke(
+          pendingPacked.map((p) => ({ name: p.name, newVersion: p.newVersion, tgzPath: p.tgzPath, sha256: p.sha256 })),
+        );
+      } catch (err) {
+        smokeVerdict = { ok: false, reason: `smoke threw: ${formatPublishError(err)}` };
+      }
+    }
+    if (pendingPacked.length === 0) {
+      /* already rolled back above */
+    } else if (!smokeVerdict.ok) {
+      for (const p of pendingPacked) {
+        try { writeFileSync(p.pkgJsonPath, p.originalPkgJson); } catch { /* best-effort restore */ }
+        if (p.originalReadme !== undefined) {
+          try { writeFileSync(p.readmePath, p.originalReadme); } catch { /* best-effort restore */ }
+        }
+        results.push({
+          name: p.name,
+          oldVersion: p.oldVersion,
+          newVersion: p.newVersion,
+          status: 'error',
+          error: `packed install smoke failed: ${smokeVerdict.reason ?? '(no detail)'}`,
+          claimCheck: p.claimCheckSummary,
+        });
+        failedInBatch.add(p.name);
+        landedInBatch.delete(p.name); // correct the pass-1 optimistic assumption
+      }
+    } else {
+      let transportFailed = false;
+      for (const p of pendingPacked) {
+        const probeLog: ProbeOutcome[] = [];
+        // Lead edit after Codex re-review (finding 2): after the first transport/receipt failure the
+        // REST of the batch is not published — a dependant must never land on top of a failed sibling.
+        if (transportFailed) {
+          try { writeFileSync(p.pkgJsonPath, p.originalPkgJson); } catch { /* best-effort restore */ }
+          if (p.originalReadme !== undefined) {
+            try { writeFileSync(p.readmePath, p.originalReadme); } catch { /* best-effort restore */ }
+          }
+          results.push({
+            name: p.name, oldVersion: p.oldVersion, newVersion: p.newVersion, status: 'error',
+            error: 'skipped: an earlier package in this batch failed to publish — dependants are not published on top of a failed sibling',
+            claimCheck: p.claimCheckSummary,
+          });
+          failedInBatch.add(p.name);
+          landedInBatch.delete(p.name);
+          continue;
+        }
+        try {
+          // Defends the "same bytes" claim against anything that could touch the tarball between
+          // the pack step and this publish call (AM-1: "a digest mismatch between smoke and
+          // publish is BLOCKED", made a real, checked code path rather than an architectural
+          // argument that the two steps happen to read the same file).
+          const currentDigest = sha256File(p.tgzPath);
+          if (currentDigest !== p.sha256) {
+            throw new Error(
+              `tarball digest changed between smoke and publish for ${p.name}@${p.newVersion} ` +
+              `(smoked ${p.sha256}, about to publish ${currentDigest}) — refusing`,
+            );
+          }
+          const publishOptions = { cwd: p.dir, stdio: 'pipe' as const, encoding: 'utf-8' as const, env: { ...process.env } };
+          const npmPublishCmd = `npm publish ${JSON.stringify(p.tgzPath)} --access public${publishCmd.includes('--provenance') ? ' --provenance' : ''}`;
+          if (opts.exec) opts.exec(npmPublishCmd, publishOptions);
+          else execSync(npmPublishCmd, publishOptions);
+
+          const { registryProbes } = confirmPublished(p.name, p.newVersion, probeLog);
+          results.push({
+            name: p.name, oldVersion: p.oldVersion, newVersion: p.newVersion, status: 'published',
+            registryProbes, probeLog, claimCheck: p.claimCheckSummary, sha256: p.sha256,
+          });
+          // landedInBatch already carries p.name from pass 1 (optimistic) — now confirmed for real.
+        } catch (err) {
+          try { writeFileSync(p.pkgJsonPath, p.originalPkgJson); } catch { /* best-effort restore */ }
+          if (p.originalReadme !== undefined) {
+            try { writeFileSync(p.readmePath, p.originalReadme); } catch { /* best-effort restore */ }
+          }
+          results.push({
+            name: p.name, oldVersion: p.oldVersion, newVersion: p.newVersion, status: 'error',
+            error: formatPublishError(err), ...(probeLog.length > 0 ? { probeLog } : {}), claimCheck: p.claimCheckSummary,
+          });
+          failedInBatch.add(p.name);
+          landedInBatch.delete(p.name);
+          transportFailed = true;
+        }
+      }
+    }
+  }
+
   const releaseLineSynced: string[] = [];
   const warnings: string[] = [];
   const releasePackageNames = new Set(['@dzhechkov/harness-core', '@dzhechkov/harness-cli']);

package/src/qe-bridge.ts

@@ -642,6 +642,19 @@ export interface BridgeAudit {
   /** sha256 of the exact prompt sent, so the digest in the signoff can be recomputed. */
   promptSha256: string | null;
   channels?: BridgeChannels;
+  /**
+   * Diagnostic sequencing metadata (qe-bridge-signoff-order): a self-reported, process-local trace of
+   * the write steps with monotonic `process.hrtime.bigint()` stamps, taken at each named event — the
+   * first and third are START/PREPARATION stamps (a record cannot carry the completion time of its
+   * own write), the second is taken AFTER the report landed; the names say so:
+   * `signoff-write-started` (first record write), `report-written` (after the report is on disk),
+   * `record-update-prepared` (right before the atomic tmp+rename that persists `reportWritten:true`;
+   * a leftover `.tmp` carrying it is not a record). Order and crash guarantees are NOT proven by this
+   * field — the first leg (record before report) is proven by the report-failure test, the second
+   * (`reportWritten:true` only after the report) by the failpoint test (hang-before-rename, R4-1);
+   * this field replaces a wall-clock mtime comparison that was a race (teach:296e5fcd).
+   */
+  writeSequence?: ReadonlyArray<{ step: 'signoff-write-started' | 'report-written' | 'record-update-prepared'; monotonicNs: string }>;
 }
 
 /**
@@ -683,6 +696,7 @@ export function buildBridgeSignoffRecord(signoff: BridgeSignoff, audit: BridgeAu
     reportWritten: audit.reportWritten,
     rawStdoutFile: audit.rawStdoutFile,
     ...(audit.channels === undefined ? {} : { channels: audit.channels }),
+    ...(audit.writeSequence === undefined ? {} : { writeSequence: audit.writeSequence }),
   };
 }
 

package/src/release.ts

@@ -23,9 +23,11 @@
 
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import type { Dirent } from 'node:fs';
-import { join } from 'node:path';
+import { join, relative } from 'node:path';
 
 import { discoverPackages, orderByDependencies } from './publish.js';
+import { planPackedInstallSmoke, judgePackedInstallSmoke } from './packed-install-smoke.js';
+import type { PackedInstallPlan, PackedInstallExecution } from './packed-install-smoke.js';
 
 /** The four HARD verify gates, in execution order. */
 export type ReleaseGateId = 'tests' | 'audit' | 'syntax' | 'smoke';
@@ -114,6 +116,15 @@ export interface GatePlan {
   readonly skips: readonly GateSkip[];
   /** Package names in the release set (dependency order). */
   readonly packages: readonly string[];
+  /**
+   * AM-7 (feature publish-sibling-drift-gate): the packed-install sub-plan, carried through so
+   * {@link classifyGateExecutions} can re-judge its `bin-version`/`bin-exists` steps through the
+   * SAME judge `dz publish` uses (`judgePackedInstallSmoke`: exit 0 AND non-empty stdout, AND the
+   * declared bin must exist post-install) instead of the generic exit-code-only check every other
+   * step gets. Without this, a silently no-op bin could pass `dz release` while `dz publish`
+   * refuses it — the two doors would not be equal, contradicting FR-6's own claim.
+   */
+  readonly packedInstallPlan?: PackedInstallPlan | undefined;
 }
 
 /** The CLI's record of running one exec step. */
@@ -303,6 +314,12 @@ export interface PlanReleaseGatesOptions {
   readonly auditTimeoutMs?: number | undefined;
   readonly syntaxTimeoutMs?: number | undefined;
   readonly smokeTimeoutMs?: number | undefined;
+  /**
+   * FR-6 (feature publish-sibling-drift-gate): real tmp dirs for the packed-install smoke,
+   * supplied by the CLI (planning stays pure — it never calls mkdtemp itself). Omitted ⇒ no
+   * packed-install steps are planned, byte-identical to the pre-feature behavior.
+   */
+  readonly packedInstall?: { readonly packDir: string; readonly installDir: string } | undefined;
 }
 
 /**
@@ -481,7 +498,50 @@ export function planReleaseGates(facts: readonly ReleasePackageFacts[], opts: Pl
     }
   }
 
-  return { steps, skips, packages: facts.map((f) => f.name) };
+  // FR-6 (feature publish-sibling-drift-gate): the packed-install smoke joins the SAME smoke
+  // gate `dz publish` runs (planPackedInstallSmoke, ADR-001 Decision 2) — so both doors apply
+  // the identical rule. Opt-in via `opts.packedInstall` (real tmp dirs, supplied by the CLI):
+  // omitted, this is byte-identical to the pre-feature plan, which every existing planner test
+  // relies on. Skipped entirely when nothing in the batch has a bin — packing siblings nobody
+  // will boot proves nothing a fresh `npm install` doesn't already cover elsewhere.
+  let packedInstallPlan: PackedInstallPlan | undefined;
+  if (opts.packedInstall !== undefined) {
+    const bins = facts.flatMap((f) =>
+      f.bins.map((b) => ({ pkg: f.name, binName: b.name, relPath: relative(f.dir, b.path) })),
+    );
+    if (bins.length > 0) {
+      const packages = facts.map((f) => ({ name: f.name, dir: f.dir, version: f.version }));
+      const smokePlan = planPackedInstallSmoke({
+        packages,
+        bins,
+        packDir: opts.packedInstall.packDir,
+        installDir: opts.packedInstall.installDir,
+      });
+      packedInstallPlan = smokePlan; // AM-7: kept for classifyGateExecutions's re-judge pass
+      for (const s of smokePlan.steps) {
+        const reason =
+          s.kind === 'pack'
+            ? `pack ${s.pkg} for the packed-install smoke — the tarball a consumer would actually receive`
+            : s.kind === 'install'
+              ? 'install every packed tarball together in a clean dir — out-of-batch siblings resolve from the registry, exactly like a fresh user'
+              : s.kind === 'bin-exists'
+                ? `bin "${s.binName}" must EXIST after the packed install (AM-8)`
+                : `bin "${s.binName}" must boot from the PACKED install (--version, exit 0, non-empty stdout)`;
+        steps.push({
+          id: `smoke:packed-install:${s.id}`,
+          gate: 'smoke',
+          pkg: s.pkg,
+          cmd: s.cmd,
+          cwd: s.cwd,
+          timeoutMs: s.timeoutMs,
+          reason,
+          kind: 'exec',
+        });
+      }
+    }
+  }
+
+  return { steps, skips, packages: facts.map((f) => f.name), ...(packedInstallPlan !== undefined ? { packedInstallPlan } : {}) };
 }
 
 /* ------------------------------------------------------------------ */
@@ -559,6 +619,30 @@ export function classifyGateExecutions(
     if (e != null && typeof e.stepId === 'string') byId.set(e.stepId, e);
   }
 
+  // AM-7: `bin-exists`/`bin-version` packed-install steps are judged through
+  // `judgePackedInstallSmoke` — the SAME rule `dz publish` applies (exit 0 AND non-empty stdout,
+  // AND the declared bin must exist post-install) — instead of the generic exit-code-only check
+  // every other step gets. The generic loop below SKIPS these step ids; the judged verdict is
+  // folded into the 'smoke' gate's failures/passed count after the loop.
+  const packedInstallPlan = plan?.packedInstallPlan;
+  const packedInstallBinStepIds = new Set(
+    (packedInstallPlan?.steps ?? []).filter((s) => s.kind === 'bin-exists' || s.kind === 'bin-version').map((s) => `smoke:packed-install:${s.id}`),
+  );
+  let packedInstallVerdict: ReturnType<typeof judgePackedInstallSmoke> | undefined;
+  if (packedInstallPlan !== undefined) {
+    const prefix = 'smoke:packed-install:';
+    const translated: PackedInstallExecution[] = (executions ?? [])
+      .filter((e): e is GateExecution => e != null && typeof e.stepId === 'string' && e.stepId.startsWith(prefix))
+      .map((e) => ({
+        stepId: e.stepId.slice(prefix.length),
+        exitCode: e.exitCode,
+        stdout: e.stdout ?? '',
+        stderr: e.stderr ?? '',
+        ...(e.timedOut !== undefined ? { timedOut: e.timedOut } : {}),
+      }));
+    packedInstallVerdict = judgePackedInstallSmoke(packedInstallPlan, translated);
+  }
+
   const gates: GateResult[] = RELEASE_GATE_ORDER.map((gate) => {
     const gateSteps = (plan?.steps ?? []).filter((s) => s?.gate === gate);
     const gateSkips = (plan?.skips ?? []).filter((s) => s?.gate === gate);
@@ -567,6 +651,7 @@ export function classifyGateExecutions(
 
     for (const step of gateSteps) {
       try {
+        if (packedInstallBinStepIds.has(step.id)) continue; // judged separately below (AM-7)
         if (step.kind === 'synthetic-fail') {
           failures.push({ pkg: step.pkg, reason: step.reason, class: step.failClass ?? 'EXIT_NONZERO' });
           continue;
@@ -609,6 +694,22 @@ export function classifyGateExecutions(
       }
     }
 
+    // AM-7: fold the packed-install bin verdicts (judged via judgePackedInstallSmoke, above) into
+    // the 'smoke' gate — the ONLY gate that ever plans packed-install steps.
+    if (gate === 'smoke' && packedInstallVerdict !== undefined) {
+      for (const bin of packedInstallVerdict.bins) {
+        if (bin.ok) {
+          passed += 1;
+        } else {
+          failures.push({
+            pkg: bin.pkg,
+            reason: `packed-install bin "${bin.binName}" ${bin.detail ?? 'failed'}`,
+            class: 'EXIT_NONZERO',
+          });
+        }
+      }
+    }
+
     const status: GateResult['status'] = failures.length > 0 ? 'fail' : passed > 0 ? 'pass' : 'skip';
     return { gate, status, passed, failures, skips: gateSkips };
   });