@dzhechkov/harness-core 0.8.46 → 0.8.47

package/src/qe-bridge.ts

@@ -32,6 +32,7 @@
  */
 
 import { extractReportGrade } from './reqe.js';
+import { readOpenRoundTaskId, type RoundState } from './round.js';
 
 export const QE_BRIDGE_SCHEMA = 'qe-bridge-signoff-1';
 export const QE_BRIDGE_FAILURE_SCHEMA = 'qe-bridge-failure-1';
@@ -155,13 +156,97 @@ export interface BridgeSignoff {
   elapsedMs: number;
   emittedAt: string;
   /** experiment-instrument FR-1/FR-3/T5 (ADR-001): the task identity of the slug's single open
-   *  round at the moment this signoff was emitted — filled by the cli (it owns `.dz/rounds/`), null
+   *  round snapshot captured before the reviewer child — filled by the cli (it owns `.dz/rounds/`), null
    *  when there was no open round to fill from, never guessed. Optional so a signoff written before
    *  this feature landed parses unchanged (NFR-1). */
   taskId?: string | null;
   /** experiment-instrument FR-1/FR-3/T5: present whenever `taskId` above was filled from a lookup —
    *  names where it came from (`readOpenRoundTaskId`'s own source, r1-1/r1-2 extended to five values). */
   taskIdSource?: 'open-round' | 'derived-legacy' | 'no-open-round' | 'ambiguous' | 'unavailable';
+  /** Pipeline round identity; runId in BridgeAudit remains the bridge invocation. */
+  round?: number | null;
+  roundRun?: string | null;
+  roundIdentitySource?: 'explicit' | 'open-round' | 'derived-legacy' | 'no-open-round' | 'ambiguous' | 'unavailable';
+}
+
+type BridgeRoundIdentity = {
+  round: number | null; roundRun: string | null; taskId: string | null;
+  taskIdSource: NonNullable<BridgeSignoff['taskIdSource']>;
+  roundIdentitySource: NonNullable<BridgeSignoff['roundIdentitySource']>;
+};
+const identityTextValid = (value: unknown, max: number): value is string =>
+  typeof value === 'string' && value.trim() !== '' && value.length <= max && !/[\u0000-\u001f\u007f]/.test(value);
+const identityRoundValid = (value: unknown): value is number => typeof value === 'number' && Number.isSafeInteger(value) && value > 0;
+
+/** Resolve copied values from ONE already-read authority snapshot, without IO or new IDs. */
+export function resolveBridgeRoundIdentity(input: {
+  slug: string; states: readonly RoundState[]; unreadableCount?: number; readError?: string;
+  explicit?: { round?: unknown; roundRun?: unknown; taskId?: unknown };
+}): { ok: true; identity: BridgeRoundIdentity } | { ok: false; reason: string } {
+  const explicit = input.explicit ?? {};
+  const hasExplicit = Object.keys(explicit).length > 0;
+  const suppliedRound = typeof explicit.round === 'string' && /^\d+$/.test(explicit.round) ? Number(explicit.round) : explicit.round;
+  if ('round' in explicit && !identityRoundValid(suppliedRound)) return { ok: false, reason: '--round must be a safe positive integer' };
+  if ('roundRun' in explicit && !identityTextValid(explicit.roundRun, 512)) return { ok: false, reason: '--round-run must be nonempty, at most 512 characters, without controls' };
+  if ('taskId' in explicit && !identityTextValid(explicit.taskId, 120)) return { ok: false, reason: '--task must be nonempty, at most 120 characters, without controls' };
+  const lookup = readOpenRoundTaskId(input.states, input.slug, input.unreadableCount ?? 0, input.readError !== undefined);
+  const empty: BridgeRoundIdentity = { round: null, roundRun: null, taskId: null, taskIdSource: lookup.source, roundIdentitySource: lookup.source };
+  if (lookup.source === 'no-open-round' || lookup.source === 'ambiguous' || lookup.source === 'unavailable') {
+    return hasExplicit ? { ok: false, reason: `round identity authority ${lookup.source}${input.readError ? ': ' + input.readError : ''}` } : { ok: true, identity: empty };
+  }
+  const state = input.states.find((s) => s.slug === input.slug)!;
+  if (!identityRoundValid(state.round) || !identityTextValid(lookup.taskId, 120) || (state.taskId != null && !identityTextValid(state.taskId, 120)) || (state.run != null && !identityTextValid(state.run, 512))) {
+    return hasExplicit ? { ok: false, reason: 'round identity authority unavailable: malformed state identity' }
+      : { ok: true, identity: { ...empty, taskIdSource: 'unavailable', roundIdentitySource: 'unavailable' } };
+  }
+  const roundRun = state.run?.trim() ?? null;
+  for (const [field, claim, current] of [['round', suppliedRound, state.round], ['roundRun', explicit.roundRun, roundRun], ['taskId', explicit.taskId, lookup.taskId]] as const) {
+    if (field in explicit && current === null) return { ok: false, reason: `round identity unverified: ${field} absent in authority` };
+    if (field in explicit && (typeof claim === 'string' ? claim.trim() : claim) !== current) return { ok: false, reason: `round identity conflict: ${field} does not match open round` };
+  }
+  return { ok: true, identity: { round: state.round, roundRun, taskId: lookup.taskId, taskIdSource: lookup.source,
+    roundIdentitySource: hasExplicit ? 'explicit' : lookup.source } };
+}
+
+/** Compare all present claims before cardinality. Raw invalid fields can never become legacy. */
+export function selectQeBridgeRoundSignoff<T extends { round?: unknown; roundRun?: unknown; taskId?: unknown; roundIdentitySource?: unknown; bridgeRunId?: string | null }>(
+  candidates: readonly T[], closing: { round: number; run?: string | null; taskId?: string | null },
+): { status: 'none' } | { status: 'ambiguous'; candidates: readonly T[] }
+  | { status: 'identity-mismatch' | 'identity-unverified'; reason: string; candidates: readonly T[] }
+  | { status: 'one'; candidate: T; reviewIdentitySource: 'round-run-task' | 'partial-identity' | 'legacy-window'; reviewIdentity: { round: number | null; roundRun: string | null; taskId: string | null; bridgeRunId: string | null } } {
+  const compatible: T[] = []; const legacy: T[] = []; const foreign: T[] = [];
+  for (const candidate of candidates) {
+    let present = 0; let mismatch = false;
+    if (candidate.roundIdentitySource != null && (typeof candidate.roundIdentitySource !== 'string' || !['explicit', 'open-round', 'derived-legacy', 'no-open-round', 'ambiguous', 'unavailable'].includes(candidate.roundIdentitySource))) {
+      return { status: 'identity-unverified', reason: 'malformed roundIdentitySource', candidates };
+    }
+    for (const [field, current, valid] of [['round', closing.round, identityRoundValid], ['roundRun', closing.run, (v: unknown) => identityTextValid(v, 512)], ['taskId', closing.taskId, (v: unknown) => identityTextValid(v, 120)]] as const) {
+      const claim = candidate[field];
+      if (claim === undefined || claim === null) continue;
+      if (!valid(claim)) return { status: 'identity-unverified', reason: `malformed ${field}`, candidates };
+      present++;
+      if (current === undefined || current === null || !valid(current)) return { status: 'identity-unverified', reason: `closing authority missing ${field}`, candidates };
+      if (claim !== current) mismatch = true;
+    }
+    if (present === 0 && ['explicit', 'open-round', 'derived-legacy'].includes(String(candidate.roundIdentitySource))) {
+      return { status: 'identity-unverified', reason: 'claimed round identity has no fields', candidates };
+    }
+    if (mismatch) foreign.push(candidate);
+    else if (present > 0) compatible.push(candidate);
+    else legacy.push(candidate);
+  }
+  if (compatible.length > 1) return { status: 'ambiguous', candidates: compatible };
+  const chosen = compatible[0] ?? (foreign.length === 0 && legacy.length === 1 ? legacy[0] : undefined);
+  if (!chosen) {
+    if (foreign.length) return { status: 'identity-mismatch', reason: 'present round/run/task differs from closing round', candidates };
+    return legacy.length > 1 ? { status: 'ambiguous', candidates: legacy } : { status: 'none' };
+  }
+  const round = chosen.round == null ? null : chosen.round as number;
+  const roundRun = chosen.roundRun == null ? null : chosen.roundRun as string;
+  const taskId = chosen.taskId == null ? null : chosen.taskId as string;
+  return { status: 'one', candidate: chosen, reviewIdentitySource: round !== null && roundRun !== null && taskId !== null ? 'round-run-task'
+    : round !== null || roundRun !== null || taskId !== null ? 'partial-identity' : 'legacy-window',
+    reviewIdentity: { round, roundRun, taskId, bridgeRunId: chosen.bridgeRunId ?? null } };
 }
 
 /** Where each channel was found, for the audit bundle: an auditor can re-derive the verdict from

package/src/release-package-audit.ts

@@ -0,0 +1,264 @@
+/** Pure evidence admission for a freshly installed release tarball (ADR-001). */
+import { createHash } from 'node:crypto';
+import { dirname, isAbsolute, posix, relative, resolve } from 'node:path';
+
+export interface ReleasePackageAuditPlan {
+  readonly package: string;
+  readonly version: string;
+  readonly dir: string;
+  readonly phases: readonly ['pack', 'install', 'validate', 'audit'];
+  readonly timeoutMs: number;
+}
+export interface ReleasePackageAuditResult {
+  readonly scope: 'package-consumer';
+  readonly package: string;
+  readonly version: string;
+  readonly status: 'clean' | 'findings' | 'error';
+  readonly failureClass?: 'AUDIT_ERROR' | 'UNEXECUTED_STEP' | 'VULNS_HIGH';
+  readonly reason?: string;
+  readonly candidateSha256?: string;
+  readonly lockSha256?: string;
+  readonly npmVersion?: string;
+  readonly platform?: { readonly os: string; readonly cpu: string };
+  readonly resolvedCount?: number;
+  readonly installedCount?: number;
+  readonly closure?: readonly { readonly path: string; readonly name: string; readonly version: string; readonly installed: boolean }[];
+  readonly optionalAbsences?: readonly { readonly name: string; readonly kind: 'optional-peer' | 'platform-excluded' | 'locked-not-installed'; readonly parent: string }[];
+  readonly counts?: Readonly<Record<string, number>>;
+  readonly findings?: readonly { readonly name: string; readonly severity: string }[];
+  readonly phases: readonly { readonly phase: string; readonly exitCode: number; readonly timedOut?: boolean }[];
+}
+export interface ReleaseWorkspaceAuditReport {
+  readonly scope: 'workspace';
+  readonly nonBlocking: true;
+  readonly includeDev: boolean;
+  readonly status: 'clean' | 'findings' | 'error' | 'not-run';
+  readonly counts?: Readonly<Record<string, number>>;
+  readonly findings?: readonly { readonly name: string; readonly severity: string }[];
+  readonly reason?: string;
+}
+type Obj = Record<string, any>;
+const obj = (value: unknown): value is Obj => value !== null && typeof value === 'object' && !Array.isArray(value);
+const integer = (v: unknown): v is number => typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
+const version = (v: unknown): v is string => typeof v === 'string' && /^\d+\.\d+\.\d+(?:[-+][\w.+-]+)?$/.test(v);
+const hash = (v: unknown): v is string => typeof v === 'string' && /^[a-f0-9]{64}$/.test(v);
+function requireEvidence(condition: unknown, reason: string): asserts condition { if (!condition) throw new Error(reason); }
+const severities = ['info', 'low', 'moderate', 'high', 'critical'] as const;
+function auditReport(input: unknown): { counts: Record<string, number>; findings: Array<{ name: string; severity: string }>; high: boolean; totalDependencies: number } {
+  requireEvidence(obj(input) && integer(input.exitCode) && input.timedOut !== true, 'audit execution is missing, malformed or timed out');
+  requireEvidence(typeof input.stdout === 'string' && input.stdout.trim() !== '', 'audit JSON is empty');
+  let report: unknown; try { report = JSON.parse(input.stdout); } catch { throw new Error('audit JSON cannot be parsed'); }
+  requireEvidence(obj(report) && report.auditReportVersion === 2 && !('error' in report), 'unsupported audit schema or error envelope');
+  requireEvidence(obj(report.metadata) && obj(report.metadata.vulnerabilities) && obj(report.vulnerabilities), 'audit vulnerability evidence is missing');
+  const counts = report.metadata.vulnerabilities;
+  requireEvidence([...severities, 'total'].every(k => integer(counts[k])), 'audit counts must be complete nonnegative integers');
+  requireEvidence(severities.reduce((sum, k) => sum + counts[k], 0) === counts.total, 'audit severity total is inconsistent');
+  const findings = Object.entries(report.vulnerabilities).map(([name, item]) => {
+    requireEvidence(obj(item) && severities.includes(item.severity), 'unknown structured advisory severity');
+    if (item.via !== undefined) {
+      requireEvidence(Array.isArray(item.via), 'via advisory evidence must be an array');
+      for (const advisory of item.via) {
+        // npm10 emits strings for metavulnerability dependencies. Those are references,
+        // not advisory objects; retain them without inventing a raw-advisory count.
+        if (typeof advisory === 'string') {
+          requireEvidence(advisory.trim().length > 0, 'via dependency reference is empty');
+          continue;
+        }
+        requireEvidence(obj(advisory) && severities.includes(advisory.severity), 'via advisory severity is unknown or malformed');
+        requireEvidence(integer(advisory.source) && ['name', 'dependency', 'title', 'url', 'range'].every(key => typeof advisory[key] === 'string'), 'via advisory object has unsupported field types');
+        // Metadata counts aggregate vulnerability entries, not individual via advisories.
+        // A lower advisory under a higher aggregate is valid; the reverse contradicts it.
+        requireEvidence(severities.indexOf(advisory.severity) <= severities.indexOf(item.severity), 'via advisory severity exceeds the vulnerability entry severity');
+      }
+    }
+    return { name, severity: item.severity as string };
+  });
+  requireEvidence(severities.every(s => findings.filter(f => f.severity === s).length === counts[s]), 'structured advisory severities contradict counts');
+  const deps = report.metadata.dependencies;
+  requireEvidence(obj(deps) && ['prod', 'dev', 'optional', 'peer', 'peerOptional', 'total'].every(k => integer(deps[k])), 'dependency count evidence is missing');
+  // These categories overlap (npm includes the synthetic consumer in prod); never sum them.
+  const high = counts.high + counts.critical > 0;
+  requireEvidence(high || input.exitCode === 0, 'nonzero audit exit without valid high/critical findings');
+  return { counts, findings, high, totalDependencies: deps.total };
+}
+/** pnpm's retained workspace JSON uses advisory IDs/counts per finding, not npm-v2 nodes. */
+function workspaceReport(input: unknown) {
+  requireEvidence(obj(input) && integer(input.exitCode) && input.timedOut !== true && typeof input.stdout === 'string', 'workspace execution unavailable');
+  let data: unknown; try { data = JSON.parse(input.stdout); } catch { throw new Error('workspace JSON cannot be parsed'); }
+  if (obj(data) && data.auditReportVersion !== undefined) return auditReport(input);
+  requireEvidence(obj(data) && !('error' in data) && Array.isArray(data.actions) && obj(data.advisories) && obj(data.metadata), 'unsupported workspace audit schema or error envelope');
+  const values = data.metadata.vulnerabilities;
+  requireEvidence(obj(values) && severities.every(k => integer(values[k])), 'workspace severity counts unavailable');
+  const counts: Record<string, number> = Object.fromEntries(severities.map(k => [k, values[k]]));
+  counts.total = severities.reduce((n, k) => n + counts[k]!, 0);
+  const findings = Object.values(data.advisories).map(item => { requireEvidence(obj(item) && typeof item.module_name === 'string' && severities.includes(item.severity), 'unsupported workspace advisory'); return { name: item.module_name as string, severity: item.severity as string }; });
+  // Legacy pnpm counters may count multiple findings for one advisory ID. Any structured
+  // severity still needs a corresponding nonzero metadata count; never synthesize clean.
+  requireEvidence(severities.every(k => counts[k]! >= findings.filter(f => f.severity === k).length), 'workspace advisory severity contradicts metadata');
+  requireEvidence(['dependencies', 'devDependencies', 'optionalDependencies', 'totalDependencies'].every(k => integer(data.metadata[k])), 'workspace dependency counters unavailable');
+  const high = counts.high! + counts.critical! > 0;
+  requireEvidence(high || input.exitCode === 0, 'workspace nonzero exit without threshold findings');
+  return { counts, findings, high, totalDependencies: data.metadata.totalDependencies as number };
+}
+export function planReleasePackageAudit(pkg: { readonly name: string; readonly version: string; readonly dir: string }, timeoutMs = 120_000): ReleasePackageAuditPlan {
+  return { package: pkg.name, version: pkg.version, dir: pkg.dir, phases: ['pack', 'install', 'validate', 'audit'], timeoutMs };
+}
+function inside(path: string, parent: string): boolean { const rel = relative(parent, path); return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel)); }
+function dependencyTables(manifest: Obj): Array<[string, Obj]> {
+  return ['dependencies', 'optionalDependencies', 'peerDependencies'].flatMap(key => {
+    if (manifest[key] === undefined) return [];
+    requireEvidence(obj(manifest[key]), `malformed ${key}`);
+    requireEvidence(Object.values(manifest[key]).every(v => typeof v === 'string'), `malformed ${key} specs`);
+    return [[key, manifest[key]]];
+  });
+}
+function dependencyPath(parent: string, name: string, nodes: Obj): string | undefined {
+  requireEvidence(/^(@[a-z0-9._-]+\/)?[a-z0-9._-]+$/i.test(name), 'unsupported dependency name');
+  let cursor = parent;
+  while (cursor !== '.' && cursor !== '') {
+    const candidate = `${cursor}/node_modules/${name}`;
+    if (nodes[candidate] !== undefined) return candidate;
+    cursor = posix.dirname(cursor);
+  }
+  const top = `node_modules/${name}`;
+  return nodes[top] === undefined ? undefined : top;
+}
+function excludesHost(metadata: unknown, host: Obj): boolean {
+  if (!obj(metadata)) return false;
+  const excludes = (values: unknown, current: string): boolean => {
+    if (values === undefined) return false;
+    requireEvidence(Array.isArray(values) && values.every(v => typeof v === 'string'), 'unsupported OS/CPU metadata');
+    const positive = values.filter(v => !v.startsWith('!'));
+    return values.includes(`!${current}`) || (positive.length > 0 && !positive.includes('any') && !positive.includes(current));
+  };
+  return excludes(metadata.os, host.os) || excludes(metadata.cpu, host.cpu);
+}
+function closure(roots: readonly { package: string; version: string; dir: string; tarball: string; integrity?: string }[], e: Obj, strictGraph = false) {
+  requireEvidence(typeof e.consumerDir === 'string' && isAbsolute(e.consumerDir) && roots.every(root => !inside(e.consumerDir, root.dir) && !inside(e.consumerDir, dirname(dirname(dirname(root.dir))))), 'consumer must be outside the workspace');
+  requireEvidence(roots.every(root => typeof root.tarball === 'string' && isAbsolute(root.tarball)), 'candidate tarball identity is missing');
+  requireEvidence(obj(e.platform) && typeof e.platform.os === 'string' && typeof e.platform.cpu === 'string' && (!strictGraph || e.platform.os.length > 0 && e.platform.cpu.length > 0), 'host platform missing');
+  requireEvidence(obj(e.lock) && [2, 3].includes(e.lock.lockfileVersion) && obj(e.lock.packages), 'unsupported consumer lock schema');
+  const nodes = e.lock.packages;
+  requireEvidence(obj(nodes['']) && version(nodes[''].version) && obj(nodes[''].dependencies), 'private versioned consumer root missing');
+  const rootPaths = new Map(roots.map(root => ['node_modules/' + root.package, root]));
+  requireEvidence(rootPaths.size === roots.length && Object.keys(nodes[''].dependencies).length === roots.length && roots.every(root => nodes[''].dependencies[root.package] === `file:${root.tarball}`), 'consumer root must contain only the selected tarball cohort');
+  for (const [path, root] of rootPaths) {
+    requireEvidence(obj(nodes[path]) && nodes[path].version === root.version && typeof nodes[path].resolved === 'string' && nodes[path].resolved.startsWith('file:') && resolve(e.consumerDir, nodes[path].resolved.slice(5)) === root.tarball, 'selected root lock identity missing');
+    if (strictGraph) requireEvidence(typeof root.integrity === 'string' && /^sha512-[A-Za-z0-9+/]+={0,2}$/.test(root.integrity) && nodes[path].integrity === root.integrity, 'selected root SRI contradicts supplied artifact');
+  }
+  requireEvidence(Array.isArray(e.installed), 'installed dependency inventory missing');
+  const installed = new Map<string, Obj>();
+  for (const entry of e.installed) {
+    requireEvidence(obj(entry) && typeof entry.path === 'string' && obj(entry.manifest) && entry.contained === true, 'installed node escapes consumer or has malformed identity');
+    requireEvidence(!installed.has(entry.path), 'duplicate installed node');
+    installed.set(entry.path, entry.manifest);
+  }
+  requireEvidence(roots.every(root => installed.get('node_modules/' + root.package)?.name === root.package && installed.get('node_modules/' + root.package)?.version === root.version), 'selected root not physically installed');
+  const absences: Array<{ name: string; kind: 'optional-peer' | 'platform-excluded' | 'locked-not-installed'; parent: string }> = [];
+  const inventory: Array<{ path: string; name: string; version: string; installed: boolean }> = [];
+  const graph: Array<Record<string, any>> = [];
+  for (const [path, node] of Object.entries(nodes)) {
+    if (path === '') continue;
+    requireEvidence(obj(node) && path.startsWith('node_modules/') && !path.split('/').some(p => p === '..' || p === '.') && !path.includes('\\') && node.link !== true && version(node.version), 'unsupported linked/versionless lock node');
+    if (!rootPaths.has(path) && node.resolved !== undefined) requireEvidence(typeof node.resolved === 'string' && /^https?:\/\//.test(node.resolved), 'dependency resolves outside registry policy');
+    if (!rootPaths.has(path) && node.resolved === undefined) requireEvidence(node.inBundle === true, 'unresolved non-bundled dependency node');
+    const manifest = installed.get(path);
+    const name = path.split('node_modules/').pop()!;
+    if (manifest !== undefined) requireEvidence(manifest.name === name && manifest.version === node.version, 'installed identity contradicts resolved lock');
+    else requireEvidence(node.optional === true && excludesHost(node, e.platform), 'resolved dependency absent without supported platform exclusion');
+    inventory.push({ path, name, version: node.version, installed: manifest !== undefined });
+    const data = manifest ?? node;
+    if (strictGraph) {
+      requireEvidence(node.dev !== true && node.extraneous !== true, 'unselected development or extraneous node is outside production cohort');
+      requireEvidence(/^(?:node_modules\/(?:@[a-z0-9._-]+\/)?[a-z0-9._-]+)(?:\/node_modules\/(?:@[a-z0-9._-]+\/)?[a-z0-9._-]+)*$/i.test(path), 'unsupported noncanonical lock path');
+      requireEvidence(data.peerDependenciesMeta === undefined || obj(data.peerDependenciesMeta) && Object.values(data.peerDependenciesMeta).every(value => obj(value) && (value.optional === undefined || typeof value.optional === 'boolean')), 'malformed optional peer metadata');
+      requireEvidence(!path.split('/').some(segment => segment === '') && (nodes[path].inBundle === true || rootPaths.has(path) || typeof node.integrity === 'string' && /^sha512-[A-Za-z0-9+/]+={0,2}$/.test(node.integrity)), 'registry node SRI or canonical path missing');
+      const equal = (a: unknown, b: unknown): boolean => JSON.stringify(Object.entries((a ?? {}) as Obj).sort()) === JSON.stringify(Object.entries((b ?? {}) as Obj).sort());
+      for (const table of ['dependencies', 'peerDependencies', 'optionalDependencies', 'peerDependenciesMeta']) requireEvidence(manifest === undefined || equal(manifest[table], node[table]), 'installed declarations contradict resolved lock');
+      for (const field of ['os', 'cpu']) requireEvidence(manifest === undefined || JSON.stringify(manifest[field]) === JSON.stringify(node[field]), 'installed platform declaration contradicts lock');
+    }
+    const edges: Array<{ table: string; name: string; spec: string; target: string | null }> = [];
+    for (const [table, declarations] of dependencyTables(data)) {
+      for (const [dep, spec] of Object.entries(declarations)) {
+        requireEvidence(!/^(?:workspace:|file:|link:|npm:)/.test(spec as string), 'unsupported local or alias dependency spec');
+        const child = dependencyPath(path, dep, nodes);
+        edges.push({ table, name: dep, spec: spec as string, target: child ?? null });
+        if (child !== undefined) {
+          if (!installed.has(child) && table === 'optionalDependencies') absences.push({ name: dep, kind: 'locked-not-installed', parent: path });
+          continue;
+        }
+        if (table === 'dependencies' && data.optionalDependencies?.[dep] !== undefined) continue;
+        if (table === 'peerDependencies' && data.peerDependenciesMeta?.[dep]?.optional === true) { absences.push({ name: dep, kind: 'optional-peer', parent: path }); continue; }
+        if (table === 'optionalDependencies' && excludesHost(e.optionalMetadata?.[`${path}:${dep}`], e.platform)) { absences.push({ name: dep, kind: 'platform-excluded', parent: path }); continue; }
+        throw new Error(`required dependency coverage missing: ${dep}`);
+      }
+    }
+    graph.push({ path, name, version: node.version, selectedRoot: rootPaths.has(path), installed: manifest !== undefined, resolved: node.resolved ?? null, integrity: node.integrity ?? null, bundled: node.inBundle === true, optional: node.optional === true, ...(strictGraph ? { optionalWitnesses: Object.fromEntries(Object.keys(data.optionalDependencies ?? {}).filter(name => dependencyPath(path, name, nodes) === undefined).map(name => [name, e.optionalMetadata?.[path + ':' + name] ?? null])) } : {}), declarations: Object.fromEntries(dependencyTables(data)), peerDependenciesMeta: data.peerDependenciesMeta ?? {}, os: data.os ?? null, cpu: data.cpu ?? null, edges: edges.sort((a, b) => (a.table + ':' + a.name).localeCompare(b.table + ':' + b.name)) });
+    const bundles = data.bundleDependencies ?? data.bundledDependencies;
+    if (bundles !== undefined && bundles !== false) {
+      requireEvidence(bundles === true || (Array.isArray(bundles) && bundles.every(n => typeof n === 'string')), 'unsupported bundle declaration');
+      const names = bundles === true ? Object.keys(data.dependencies ?? {}) : bundles;
+      for (const name of names) {
+        const child = dependencyPath(path, name, nodes);
+        requireEvidence(child !== undefined && nodes[child].inBundle === true && installed.has(child), 'bundled bytes absent from installed audited inventory');
+      }
+    }
+  }
+  requireEvidence([...installed.keys()].every(path => nodes[path] !== undefined), 'installed node absent from lock coverage');
+  return { inventory, absences, graph: graph.sort((a, b) => a.path.localeCompare(b.path)) };
+}
+export function judgeReleasePackageAudit(plan: ReleasePackageAuditPlan, evidence: unknown): ReleasePackageAuditResult;
+export function judgeReleasePackageAudit(plan: undefined, evidence: unknown, includeDev?: boolean): ReleaseWorkspaceAuditReport;
+export function judgeReleasePackageAudit(plan: ReleasePackageAuditPlan | undefined, evidence: unknown, includeDev = false): ReleasePackageAuditResult | ReleaseWorkspaceAuditReport {
+  if (plan === undefined) {
+    const base = { scope: 'workspace' as const, nonBlocking: true as const, includeDev: includeDev || (obj(evidence) && evidence.includeDev === true) };
+    if (evidence === undefined) return { ...base, status: 'not-run', reason: 'workspace audit was not executed' };
+    try { const r = workspaceReport(evidence); return { ...base, status: r.counts.total! > 0 ? 'findings' : 'clean', counts: r.counts, findings: r.findings }; }
+    catch (error) { return { ...base, status: 'error', reason: error instanceof Error ? error.message : 'workspace audit unavailable' }; }
+  }
+  const base = { scope: 'package-consumer' as const, package: plan.package, version: plan.version };
+  let phases: ReleasePackageAuditResult['phases'] = [];
+  try {
+    requireEvidence(obj(evidence), 'package audit evidence missing'); const e = evidence;
+    requireEvidence(e.package === plan.package && e.version === plan.version, 'package audit identity mismatch');
+    requireEvidence(Array.isArray(e.phases), 'package phase records missing');
+    phases = e.phases.map((p: unknown) => { requireEvidence(obj(p) && typeof p.phase === 'string' && integer(p.exitCode), 'malformed phase record'); return { phase: p.phase, exitCode: p.exitCode, ...(p.timedOut === true ? { timedOut: true } : {}) }; });
+    requireEvidence(plan.phases.join(',') === 'pack,install,validate,audit' && phases.map(p => p.phase).join(',') === plan.phases.join(','), 'required package phase missing, duplicated or reordered');
+    requireEvidence(phases.every(p => p.timedOut !== true && (p.phase === 'audit' || p.exitCode === 0)), 'package phase failed or timed out');
+    requireEvidence(e.sourceRestored === true && e.cleanup === true, 'source restoration or owned scratch cleanup not established');
+    requireEvidence(hash(e.candidateSha256) && hash(e.lockSha256), 'candidate/lock digest missing');
+    requireEvidence(typeof e.npmVersion === 'string' && /^10\.\d+\.\d+$/.test(e.npmVersion), 'unsupported or missing npm version');
+    const c = closure([{ ...plan, tarball: e.tarball }], e); const r = auditReport(e.audit);
+    requireEvidence(r.totalDependencies === c.inventory.length, 'audit dependency total does not cover the validated lock inventory');
+    requireEvidence(phases[3]!.exitCode === e.audit.exitCode, 'audit phase and execution exits disagree');
+    return { ...base, status: r.high ? 'findings' : 'clean', ...(r.high ? { failureClass: 'VULNS_HIGH' as const, reason: `${r.counts.total} vulnerabilities found (high ${r.counts.high}, critical ${r.counts.critical})` } : {}), phases,
+      candidateSha256: e.candidateSha256, lockSha256: e.lockSha256, npmVersion: e.npmVersion, platform: e.platform,
+      resolvedCount: c.inventory.length, installedCount: e.installed.length, closure: c.inventory, optionalAbsences: c.absences, counts: r.counts, findings: r.findings };
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : 'package audit unavailable';
+    const e = obj(evidence) ? evidence : {};
+    return { ...base, status: 'error', failureClass: reason.includes('phase missing') || reason.includes('evidence missing') ? 'UNEXECUTED_STEP' : 'AUDIT_ERROR', reason, phases,
+      ...(hash(e.candidateSha256) ? { candidateSha256: e.candidateSha256 } : {}), ...(hash(e.lockSha256) ? { lockSha256: e.lockSha256 } : {}),
+      ...(version(e.npmVersion) ? { npmVersion: e.npmVersion } : {}),
+      ...(obj(e.platform) && typeof e.platform.os === 'string' && typeof e.platform.cpu === 'string' ? { platform: { os: e.platform.os, cpu: e.platform.cpu } } : {}) };
+  }
+}
+
+
+/** Additional five-root admission; the singleton judge uses the same closure/edge/audit validators. */
+export function judgeReleaseCohortAudit(roots: readonly { readonly package: string; readonly version: string; readonly dir: string; readonly tarball: string; readonly sha256: string; readonly integrity: string }[], evidence: unknown): { scope: 'package-cohort'; status: 'clean' | 'findings' | 'error'; reason?: string; graph?: readonly Record<string, any>[]; optionalAbsences?: readonly { name: string; kind: string; parent: string }[]; resolvedCount?: number; counts?: Readonly<Record<string, number>> } {
+  const base = { scope: 'package-cohort' as const };
+  try {
+    const expected = ['harness-core', 'harness-cli', 'skills-meta', 'keysarium', 'skills-feature-adr'].map(name => '@dzhechkov/' + name).sort();
+    requireEvidence(Array.isArray(roots) && roots.length === 5 && JSON.stringify(roots.map(root => root.package).sort()) === JSON.stringify(expected), 'cohort must be the exact authorized five');
+    requireEvidence(roots.every(root => version(root.version) && hash(root.sha256) && typeof root.dir === 'string' && isAbsolute(root.dir) && typeof root.tarball === 'string' && isAbsolute(root.tarball) && root.tarball === resolve(root.tarball)) && new Set(roots.map(root => root.tarball)).size === roots.length, 'cohort root artifact identity incomplete');
+    requireEvidence(obj(evidence) && evidence.cleanup === true && evidence.sourceRestored === true && hash(evidence.lockSha256) && /^10\.\d+\.\d+$/.test(evidence.npmVersion), 'cohort execution, restoration or cleanup evidence incomplete');
+    const e = evidence;
+    requireEvidence(typeof e.lockBytes === 'string' && Buffer.byteLength(e.lockBytes) <= 16 * 1024 * 1024 && createHash('sha256').update(e.lockBytes).digest('hex') === e.lockSha256 && JSON.stringify(JSON.parse(e.lockBytes)) === JSON.stringify(e.lock), 'cohort raw lock/digest/object evidence disagree');
+    requireEvidence(Array.isArray(e.phases) && e.phases.map((p: Obj) => p.phase).join(',') === 'pack,install,validate,audit' && e.phases.every((p: Obj) => integer(p.exitCode) && p.timedOut !== true && (p.phase === 'audit' || p.exitCode === 0)), 'cohort execution phases missing or failed');
+    const c = closure(roots, e, true); const audit = auditReport(e.audit);
+    requireEvidence(c.inventory.length <= 10000 && audit.totalDependencies === c.inventory.length && e.phases[3].exitCode === e.audit.exitCode, 'cohort audit does not cover the complete lock');
+    if (audit.high) return { ...base, status: 'findings', reason: 'cohort has high/critical findings', counts: audit.counts };
+    return { ...base, status: 'clean', graph: c.graph, optionalAbsences: c.absences, resolvedCount: c.inventory.length, counts: audit.counts };
+  } catch (error) { return { ...base, status: 'error', reason: error instanceof Error ? error.message : 'cohort admission unavailable' }; }
+}

package/src/release.ts

@@ -25,7 +25,10 @@ import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import type { Dirent } from 'node:fs';
 import { join, relative } from 'node:path';
 
-import { discoverPackages, matchesPublishFilter, orderByDependencies } from './publish.js';
+import { planReleasePackageAudit, judgeReleasePackageAudit } from './release-package-audit.js';
+import type { ReleasePackageAuditPlan, ReleasePackageAuditResult, ReleaseWorkspaceAuditReport } from './release-package-audit.js';
+
+import { discoverPackages, matchesPublishFilter, validatePublishFilters, orderByDependencies } from './publish.js';
 import { planPackedInstallSmoke, judgePackedInstallSmoke } from './packed-install-smoke.js';
 import type { PackedInstallPlan, PackedInstallExecution } from './packed-install-smoke.js';
 
@@ -90,7 +93,7 @@ export interface GateStep {
    * `exec` (default): the CLI runs `cmd`. `synthetic-fail`: the PLAN already knows this step
    * fails (missing bin, stale dist) — classification sees it without any execution.
    */
-  readonly kind?: 'exec' | 'synthetic-fail' | undefined;
+  readonly kind?: 'exec' | 'synthetic-fail' | 'package-audit' | undefined;
   /** For `synthetic-fail` steps: the failure class the verdict must carry. */
   readonly failClass?: ReleaseFailureClass | undefined;
   /**
@@ -125,6 +128,9 @@ export interface GatePlan {
    * refuses it — the two doors would not be equal, contradicting FR-6's own claim.
    */
   readonly packedInstallPlan?: PackedInstallPlan | undefined;
+  readonly packageAuditPlans?: readonly ReleasePackageAuditPlan[];
+  readonly workspaceAuditStep?: GateStep;
+  readonly workspaceAuditIncludeDev?: boolean;
 }
 
 /** The CLI's record of running one exec step. */
@@ -134,6 +140,7 @@ export interface GateExecution {
   readonly stdout: string;
   readonly stderr: string;
   readonly durationMs: number;
+  readonly packageAuditEvidence?: unknown;
   readonly timedOut?: boolean | undefined;
 }
 
@@ -175,6 +182,8 @@ export interface ReleaseVerdict {
   /** Fail-closed decision point: `'proceed'` iff every gate is clean AND something ran. */
   readonly publishAction: 'proceed' | 'blocked';
   readonly timestamp: string;
+  readonly packageAudits: readonly ReleasePackageAuditResult[];
+  readonly workspaceAudit: ReleaseWorkspaceAuditReport;
 }
 
 /** Default per-step timeouts (NFR-4: a hung child is a classified failure, not a hung release). */
@@ -249,6 +258,7 @@ export function collectPackageFacts(monorepoRoot: string, filter?: readonly stri
     throw new Error('release: --filter requires non-empty package-name substrings (empty would match ALL packages)');
   }
   const discovered = discoverPackages(monorepoRoot);
+  validatePublishFilters(filter, discovered);
   const selected =
     filter === undefined ? discovered : discovered.filter((p) => filter.some((f) => matchesPublishFilter(p, f, monorepoRoot)));
   const ordered = orderByDependencies(selected);
@@ -379,21 +389,22 @@ export function planReleaseGates(facts: readonly ReleasePackageFacts[], opts: Pl
     }
   }
 
-  // Gate 2 — audit: ONE workspace-level step (AM-1: pnpm primary; npm only without pnpm-lock).
+  // HARD audit: every selected root, including binless/dependency-free packages.
+  const packageAuditPlans = facts.map(f => planReleasePackageAudit(f, t.audit));
+  for (const audit of packageAuditPlans) steps.push({
+    id: `audit:package:${audit.package}`, gate: 'audit', pkg: audit.package,
+    cmd: 'pack → install (--ignore-scripts, prod/optional/peer) → validate closure → npm audit --json --audit-level=high',
+    cwd: audit.dir, timeoutMs: t.audit, reason: 'isolated selected tarball consumer must have no high/critical advisories', kind: 'package-audit',
+  });
   const dev = opts.includeDevDeps === true;
-  steps.push({
-    id: 'audit:workspace',
-    gate: 'audit',
+  const workspaceAuditStep: GateStep = {
+    id: 'audit:workspace', gate: 'audit',
     cmd: opts.pnpmLockPresent
-      ? `pnpm audit${dev ? '' : ' --prod'} --audit-level high`
-      : `npm audit${dev ? '' : ' --omit=dev'} --audit-level=high`,
-    cwd: opts.monorepoRoot,
-    timeoutMs: t.audit,
-    reason: dev
-      ? 'no >=high advisories across ALL workspace dependencies (dev included via --audit-dev)'
-      : 'no >=high advisories in production dependencies (dev-only chains excluded — widen with --audit-dev)',
-    kind: 'exec',
-  });
+      ? `pnpm audit${dev ? '' : ' --prod'} --audit-level high --json`
+      : `npm audit${dev ? '' : ' --omit=dev'} --audit-level=high --json --offline=false`,
+    cwd: opts.monorepoRoot, timeoutMs: t.audit,
+    reason: 'separate nonblocking workspace advisory observation', kind: 'exec',
+  };
 
   // Gates 3+4 — per package. AM-3: a stale dist is NEVER checked/booted as-is.
   for (const f of facts) {
@@ -559,7 +570,7 @@ export function planReleaseGates(facts: readonly ReleasePackageFacts[], opts: Pl
     }
   }
 
-  return { steps, skips, packages: facts.map((f) => f.name), ...(packedInstallPlan !== undefined ? { packedInstallPlan } : {}) };
+  return { packageAuditPlans, workspaceAuditStep, workspaceAuditIncludeDev: dev, steps, skips, packages: facts.map((f) => f.name), ...(packedInstallPlan !== undefined ? { packedInstallPlan } : {}) };
 }
 
 /* ------------------------------------------------------------------ */
@@ -802,6 +813,23 @@ export function classifyGateExecutions(
     packedInstallVerdict = judgePackedInstallSmoke(packedInstallPlan, translated);
   }
 
+  const packageAudits: ReleasePackageAuditResult[] = [];
+  for (const name of plan?.packages ?? []) {
+    const auditPlans = (plan.packageAuditPlans ?? []).filter(p => p.package === name);
+    const steps = (plan.steps ?? []).filter(s => s.gate === 'audit' && s.pkg === name && s.kind === 'package-audit');
+    const records = (executions ?? []).filter(e => e?.stepId === `audit:package:${name}`);
+    if (auditPlans.length !== 1 || steps.length !== 1 || records.length !== 1) {
+      packageAudits.push({ scope: 'package-consumer', package: name, version: auditPlans[0]?.version ?? '', status: 'error', failureClass: 'UNEXECUTED_STEP', reason: 'selected package audit plan/step/execution missing or duplicated', phases: [] });
+    } else {
+      const result = judgeReleasePackageAudit(auditPlans[0]!, records[0]!.packageAuditEvidence);
+      packageAudits.push(records[0]!.timedOut === true || (result.status === 'clean' && records[0]!.exitCode !== 0)
+        ? { ...result, status: 'error', failureClass: 'AUDIT_ERROR', reason: 'package audit wrapper timeout or exit/evidence inconsistency' }
+        : result);
+    }
+  }
+  const workspaceRecords = (executions ?? []).filter(e => e?.stepId === 'audit:workspace');
+  const workspaceAudit = judgeReleasePackageAudit(undefined, workspaceRecords.length === 1 ? { ...workspaceRecords[0], includeDev: plan.workspaceAuditIncludeDev === true } : undefined, plan.workspaceAuditIncludeDev === true);
+
   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);
@@ -810,6 +838,8 @@ export function classifyGateExecutions(
 
     for (const step of gateSteps) {
       try {
+        if (gate === 'audit') continue; // typed per-root judge below owns this gate
+
         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' });
@@ -836,11 +866,6 @@ export function classifyGateExecutions(
           continue;
         }
         if (typeof exec.exitCode !== 'number' || exec.exitCode !== 0) {
-          if (gate === 'audit') {
-            const { cls, reason } = classifyAuditFailure(`${exec.stdout ?? ''}\n${exec.stderr ?? ''}`);
-            const detail = auditDetailLine(exec.stdout, exec.stderr);
-            failures.push({ pkg: step.pkg, reason: `${reason}${detail ? ` — ${detail}` : ''}`, class: cls });
-          } else {
             // FR-1: for tests/syntax/smoke, name the ACTUAL failure (summary + failing tests),
             // not just the first output line — see testsFailureDetail's doc comment for why.
             const detail = testsFailureDetail(exec.stderr, exec.stdout);
@@ -851,7 +876,6 @@ export function classifyGateExecutions(
               // AM-4: per-stream tails, never merged — see GateFailure.tails doc comment.
               tails: { stdout: outputTail(exec.stdout, undefined), stderr: outputTail(undefined, exec.stderr) },
             });
-          }
           continue;
         }
         passed += 1;
@@ -861,6 +885,13 @@ export function classifyGateExecutions(
       }
     }
 
+    if (gate === 'audit') {
+      for (const result of packageAudits) {
+        if (result.status === 'clean') passed += 1;
+        else failures.push({ pkg: result.package, class: result.failureClass ?? 'AUDIT_ERROR', reason: result.reason ?? 'package consumer audit unavailable' });
+      }
+    }
+
     // 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) {
@@ -893,6 +924,8 @@ export function classifyGateExecutions(
 
   return {
     gates,
+    packageAudits,
+    workspaceAudit,
     ok,
     blockedBy,
     skipped: plan?.skips ?? [],

package/src/round.ts

@@ -102,6 +102,8 @@ export interface RoundLedgerRow {
    *  fix-round-1 #1/#2 (ADR-001 п.2 amended): also present when an EXPLICIT `--reviewer` AGREES with
    *  the sidecar's own `gradedBy` (`reviewSource:'flag+qe-bridge'` below names that case). */
   readonly reviewMinutes?: number;
+  readonly reviewIdentitySource?: 'round-run-task' | 'partial-identity' | 'legacy-window';
+  readonly reviewIdentity?: { readonly round: number | null; readonly roundRun: string | null; readonly taskId: string | null; readonly bridgeRunId: string | null };
   /** measurement-integrity FR-7: present ONLY alongside `reviewMinutes` — names where `reviewer` and
    *  `reviewMinutes` came from, so a reader never confuses a sidecar-sourced figure for a flag.
    *  review-cost-ledger fix-round-1 #1/#2 (ADR-001 п.2 amended): `'qe-bridge'` when `reviewer` was
@@ -188,6 +190,8 @@ export interface RoundLedgerRow {
  * `closeRound` never opens a file.
  */
 export interface RoundReviewSidecar {
+  readonly reviewIdentitySource?: RoundLedgerRow['reviewIdentitySource'];
+  readonly reviewIdentity?: RoundLedgerRow['reviewIdentity'];
   /** Who graded it — family + model, e.g. `codex:gpt-5.6-sol`. */
   readonly gradedBy: string;
   readonly elapsedMs: number;
@@ -609,6 +613,8 @@ export function closeRound(input: {
     ...(nonEmpty(input.stateId) ? { stateId: input.stateId } : {}),
     ...(input.state.envelope !== undefined ? { envelope: input.state.envelope } : {}),
     ...(reviewSource !== null ? { reviewSource } : {}),
+    ...(reviewerTiedToSidecar && input.reviewSidecar?.reviewIdentitySource !== undefined ? { reviewIdentitySource: input.reviewSidecar.reviewIdentitySource } : {}),
+    ...(reviewerTiedToSidecar && input.reviewSidecar?.reviewIdentity !== undefined ? { reviewIdentity: input.reviewSidecar.reviewIdentity } : {}),
     ...(reviewMinutes !== null ? { reviewMinutes } : {}),
     taskId,
     ...(taskIdSource !== null ? { taskIdSource } : {}),
@@ -700,11 +706,13 @@ export function readOpenRoundTaskId(
   states: readonly RoundState[],
   slug: string,
   unreadableStateCount = 0,
+  authorityReadError = false,
 ): {
   readonly taskId: string | null;
   readonly source: 'open-round' | 'derived-legacy' | 'no-open-round' | 'ambiguous' | 'unavailable';
 } {
   const matches = states.filter((s) => s.slug === slug);
+  if (authorityReadError) return { taskId: null, source: 'unavailable' };
   const unreadable = Number.isFinite(unreadableStateCount) && unreadableStateCount > 0 ? Math.floor(unreadableStateCount) : 0;
   if (unreadable > 0 && matches.length === 0) return { taskId: null, source: 'unavailable' };
   if (unreadable > 0) return { taskId: null, source: 'ambiguous' };