harnery 0.35.0 → 0.37.0

package/src/core/diagnostics/sanitize.ts

@@ -0,0 +1,97 @@
+const SENSITIVE_KEY =
+  /(?:authorization|cookie|credential|password|passwd|private[_-]?key|secret|session[_-]?token|access[_-]?token|refresh[_-]?token|api[_-]?key)/i;
+const OMITTED_CONTENT_KEY =
+  /(?:^|[_-])(?:environment|env|prompt|prompts|tool[_-]?payload|tool[_-]?result|transcript|transcripts)(?:$|[_-])/i;
+const HOME_PATH = /(?:[A-Za-z]:\\Users\\[^\\\s]+|\/home\/[^/\s]+|\/Users\/[^/\s]+)/g;
+const BEARER_VALUE = /\bBearer\s+[A-Za-z0-9._~+/-]+=*/gi;
+const URL_CREDENTIALS = /([a-z][a-z0-9+.-]*:\/\/)[^\s/@:]+:[^\s/@]+@/gi;
+const PRIVATE_KEY = /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g;
+const TOKENISH_VALUE = /\b(?:sk|pk|ghp|github_pat|xox[baprs])[-_][A-Za-z0-9_-]{16,}\b/g;
+const AWS_ACCESS_KEY = /\bAKIA[A-Z0-9]{16,}\b/g;
+const SENSITIVE_QUERY = /([?&](?:access_token|api_key|key|password|secret|token)=)[^&#\s]+/gi;
+const SENSITIVE_ENV = /(\b[A-Z0-9_]*(?:API_KEY|PASSWORD|SECRET|TOKEN)=)[^\s]+/g;
+const SENSITIVE_ARGUMENT = /(\B--?(?:access-token|api-key|password|secret|token)\s+)[^\s]+/gi;
+
+export interface SanitizationStats {
+  sanitized_value_count: number;
+  omitted_value_count: number;
+}
+
+export function sanitizeDiagnosticValue(value: unknown): {
+  value: unknown;
+  stats: SanitizationStats;
+} {
+  const stats: SanitizationStats = { sanitized_value_count: 0, omitted_value_count: 0 };
+  return { value: sanitize(value, stats, 0), stats };
+}
+
+function sanitize(value: unknown, stats: SanitizationStats, depth: number): unknown {
+  if (depth > 24) {
+    stats.omitted_value_count += 1;
+    return "[OMITTED:depth-limit]";
+  }
+  if (value === null || typeof value === "boolean" || typeof value === "number") return value;
+  if (typeof value === "string") return sanitizeString(value, stats);
+  if (Array.isArray(value)) {
+    const sliced = value.slice(0, 5_000);
+    const kept = sliced.map((item, index) => {
+      if (
+        typeof sliced[index - 1] === "string" &&
+        /^(?:--?)(?:access-token|api-key|password|secret|token)$/i.test(sliced[index - 1] as string)
+      ) {
+        stats.sanitized_value_count += 1;
+        return "[REDACTED:argument]";
+      }
+      return sanitize(item, stats, depth + 1);
+    });
+    if (kept.length !== value.length) stats.omitted_value_count += value.length - kept.length;
+    return kept;
+  }
+  if (!value || typeof value !== "object") return String(value);
+
+  const result: Record<string, unknown> = {};
+  const entries = Object.entries(value);
+  const namedSensitiveField = entries.some(
+    ([key, item]) => key === "name" && typeof item === "string" && SENSITIVE_KEY.test(item),
+  );
+  for (const [key, item] of entries) {
+    if (OMITTED_CONTENT_KEY.test(key)) {
+      result[key] = "[OMITTED:sensitive-content]";
+      stats.omitted_value_count += 1;
+      continue;
+    }
+    if (key === "value" && namedSensitiveField) {
+      result[key] = "[REDACTED:sensitive-field]";
+      stats.sanitized_value_count += 1;
+      continue;
+    }
+    if (SENSITIVE_KEY.test(key)) {
+      result[key] = "[REDACTED:sensitive-field]";
+      stats.sanitized_value_count += 1;
+      continue;
+    }
+    result[key] = sanitize(item, stats, depth + 1);
+  }
+  return result;
+}
+
+function sanitizeString(value: string, stats: SanitizationStats): string {
+  let next = value;
+  const replacements: Array<[RegExp, string | ((...args: string[]) => string)]> = [
+    [PRIVATE_KEY, "[REDACTED:private-key]"],
+    [BEARER_VALUE, "Bearer [REDACTED:token]"],
+    [TOKENISH_VALUE, "[REDACTED:token]"],
+    [AWS_ACCESS_KEY, "[REDACTED:access-key]"],
+    [SENSITIVE_QUERY, "$1[REDACTED]"],
+    [SENSITIVE_ENV, "$1[REDACTED]"],
+    [SENSITIVE_ARGUMENT, "$1[REDACTED]"],
+    [URL_CREDENTIALS, (_match, scheme: string) => `${scheme}[REDACTED]@`],
+    [HOME_PATH, "[REDACTED:home]"],
+  ];
+  for (const [pattern, replacement] of replacements) {
+    const replaced = next.replace(pattern, replacement as never);
+    if (replaced !== next) stats.sanitized_value_count += 1;
+    next = replaced;
+  }
+  return next;
+}

package/src/core/events/legacy-storage/canary.ts

@@ -0,0 +1,177 @@
+import { createHash } from "node:crypto";
+import { constants, createReadStream, createWriteStream } from "node:fs";
+import { chmod, lstat, mkdir, open, rename, rm } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { createGzip } from "node:zlib";
+import { canonicalJsonV3 } from "../v3/canonical.ts";
+import { verifyLegacyV1HardFence } from "./fence.ts";
+import { type LegacyV1SegmentManifest, validateLegacyV1SegmentManifest } from "./manifest.ts";
+import { streamLegacyV1Rows } from "./reader.ts";
+
+export interface LegacyV1CanaryResult {
+  manifest: LegacyV1SegmentManifest;
+  manifest_path: string;
+  payload_path: string;
+  source_unchanged: true;
+  replacement_enabled: false;
+}
+
+/** Shadow-compress one fenced legacy segment, then prove byte and row parity. */
+export async function writeLegacyV1Canary(input: {
+  coord_root: string;
+  source_filename: string;
+  output_directory: string;
+  minimum_harnery_version: string;
+  created_at: string;
+}): Promise<LegacyV1CanaryResult> {
+  await verifyLegacyV1HardFence(input.coord_root);
+  if (
+    !/^events.+\.ndjson$/.test(input.source_filename) ||
+    input.source_filename.includes("/") ||
+    input.source_filename.includes("\\")
+  ) {
+    throw new Error("legacy_v1_canary_source_name_invalid");
+  }
+  const harnery = resolve(input.coord_root, ".harnery");
+  const source = join(harnery, input.source_filename);
+  const sourceStat = await lstat(source);
+  if (!sourceStat.isFile() || sourceStat.isSymbolicLink()) {
+    throw new Error("legacy_v1_canary_source_not_regular");
+  }
+  const sourceDigest = await hashFile(source);
+  const sourceFacts = await inspectRows(source);
+  const segmentId = `v1s_${createHash("sha256")
+    .update(`${input.source_filename}\0${sourceStat.size}\0${sourceDigest}`)
+    .digest("hex")
+    .slice(0, 32)}` as const;
+  const outputDirectory = resolve(input.output_directory);
+  await mkdir(outputDirectory, { recursive: true, mode: 0o700 });
+  await chmod(outputDirectory, 0o700);
+  const payloadPath = join(outputDirectory, `${segmentId}.ndjson.gz`);
+  const manifestPath = join(outputDirectory, `${segmentId}.manifest.json`);
+  const partialPayload = `${payloadPath}.partial`;
+  const partialManifest = `${manifestPath}.partial`;
+  await rejectExisting([payloadPath, manifestPath, partialPayload, partialManifest]);
+  try {
+    await pipeline(
+      createReadStream(source),
+      createGzip({ level: 9 }),
+      createWriteStream(partialPayload, { flags: "wx", mode: 0o600 }),
+    );
+    await rename(partialPayload, payloadPath);
+    const payloadStat = await lstat(payloadPath);
+    const manifest = validateLegacyV1SegmentManifest({
+      format: "harnery-legacy-v1-segment",
+      format_version: 1,
+      segment_id: segmentId,
+      source: {
+        filename: input.source_filename,
+        bytes: sourceStat.size,
+        digest: sourceDigest,
+        row_count: sourceFacts.rows,
+        minimum_recorded_at: sourceFacts.minimum,
+        maximum_recorded_at: sourceFacts.maximum,
+      },
+      payload: {
+        algorithm: "gzip",
+        path: basename(payloadPath),
+        bytes: payloadStat.size,
+        digest: await hashFile(payloadPath),
+      },
+      minimum_harnery_version: input.minimum_harnery_version,
+      created_at: input.created_at,
+    });
+    const handle = await open(
+      partialManifest,
+      constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL,
+      0o600,
+    );
+    try {
+      await handle.writeFile(`${canonicalJsonV3(manifest)}\n`, "utf8");
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await rename(partialManifest, manifestPath);
+    await proveRowParity(source, manifestPath);
+    const after = await lstat(source);
+    if (after.size !== sourceStat.size || (await hashFile(source)) !== sourceDigest) {
+      throw new Error("legacy_v1_canary_source_changed");
+    }
+    return {
+      manifest,
+      manifest_path: manifestPath,
+      payload_path: payloadPath,
+      source_unchanged: true,
+      replacement_enabled: false,
+    };
+  } catch (error) {
+    await rm(partialPayload, { force: true });
+    await rm(partialManifest, { force: true });
+    await rm(payloadPath, { force: true });
+    await rm(manifestPath, { force: true });
+    throw error;
+  }
+}
+
+export function activateLegacyV1CanaryReplacement(): never {
+  throw new Error("legacy_v1_replacement_activation_disabled");
+}
+
+async function inspectRows(
+  path: string,
+): Promise<{ rows: number; minimum: string | null; maximum: string | null }> {
+  let rows = 0;
+  const timestamps: string[] = [];
+  for await (const row of streamLegacyV1Rows(path)) {
+    rows += 1;
+    const value = JSON.parse(row.bytes.toString("utf8")) as Record<string, unknown>;
+    const candidate =
+      typeof value.at === "string"
+        ? value.at
+        : typeof value.timestamp === "string"
+          ? value.timestamp
+          : value.time &&
+              typeof value.time === "object" &&
+              typeof (value.time as Record<string, unknown>).observed_at === "string"
+            ? ((value.time as Record<string, unknown>).observed_at as string)
+            : undefined;
+    if (candidate && Number.isFinite(Date.parse(candidate)))
+      timestamps.push(new Date(candidate).toISOString());
+  }
+  timestamps.sort();
+  return { rows, minimum: timestamps[0] ?? null, maximum: timestamps.at(-1) ?? null };
+}
+
+async function proveRowParity(loose: string, manifest: string): Promise<void> {
+  const left = streamLegacyV1Rows(loose)[Symbol.asyncIterator]();
+  const right = streamLegacyV1Rows(manifest)[Symbol.asyncIterator]();
+  while (true) {
+    const [looseRow, packedRow] = await Promise.all([left.next(), right.next()]);
+    if (looseRow.done || packedRow.done) {
+      if (looseRow.done !== packedRow.done) throw new Error("legacy_v1_canary_row_count_mismatch");
+      break;
+    }
+    if (!looseRow.value.bytes.equals(packedRow.value.bytes)) {
+      throw new Error(`legacy_v1_canary_row_mismatch:${looseRow.value.row_number}`);
+    }
+  }
+}
+
+async function hashFile(path: string): Promise<`sha256:${string}`> {
+  const hash = createHash("sha256");
+  for await (const current of createReadStream(path)) hash.update(current as Buffer);
+  return `sha256:${hash.digest("hex")}`;
+}
+
+async function rejectExisting(paths: string[]): Promise<void> {
+  for (const path of paths) {
+    try {
+      await lstat(path);
+      throw new Error("legacy_v1_canary_output_exists");
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}

package/src/core/events/legacy-storage/compression.ts

@@ -0,0 +1,130 @@
+/** Verified in-place compression for sealed, non-terminal legacy V1 shards. */
+
+import { createReadStream, createWriteStream } from "node:fs";
+import { chmod, lstat, rename, rm } from "node:fs/promises";
+import { basename } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { createGzip } from "node:zlib";
+import { verifyLegacyV1HardFence } from "./fence.ts";
+import { inventoryLegacyV1Segments } from "./inventory.ts";
+import { streamLegacyV1Rows } from "./reader.ts";
+
+export interface LegacyV1CompressionEntry {
+  filename: string;
+  path: string;
+  bytes_before: number;
+  bytes_after: number | null;
+  action: "keep" | "would-compress" | "compressed";
+  reason: string;
+}
+
+export async function compressSealedLegacyV1Segments(
+  coordRoot: string,
+  opts: { yes?: boolean } = {},
+): Promise<LegacyV1CompressionEntry[]> {
+  const fence = await verifyLegacyV1HardFence(coordRoot);
+  const terminal = basename(fence.terminal_archive_path);
+  const inventory = await inventoryLegacyV1Segments(coordRoot);
+  const rows = inventory.map<LegacyV1CompressionEntry>((entry) => {
+    if (entry.filename === terminal) {
+      return {
+        filename: entry.filename,
+        path: entry.path,
+        bytes_before: entry.bytes,
+        bytes_after: null,
+        action: "keep",
+        reason: "terminal shard is bound by the V1 hard-fence digest",
+      };
+    }
+    if (entry.compressed) {
+      return {
+        filename: entry.filename,
+        path: entry.path,
+        bytes_before: entry.bytes,
+        bytes_after: entry.bytes,
+        action: "keep",
+        reason: "already compressed",
+      };
+    }
+    return {
+      filename: entry.filename,
+      path: entry.path,
+      bytes_before: entry.bytes,
+      bytes_after: null,
+      action: "would-compress",
+      reason: "sealed non-terminal V1 shard",
+    };
+  });
+  if (!opts.yes) return rows;
+
+  for (const row of rows) {
+    if (row.action !== "would-compress") continue;
+    const expected = inventory.find((entry) => entry.path === row.path)!;
+    const current = (await inventoryLegacyV1Segments(coordRoot)).find(
+      (entry) => entry.path === row.path,
+    );
+    if (
+      !current ||
+      current.bytes !== expected.bytes ||
+      current.digest !== expected.digest ||
+      current.compressed
+    ) {
+      throw new Error(`legacy_v1_segment_changed_before_compression:${row.filename}`);
+    }
+    const sourceStat = await lstat(row.path);
+    const destination = `${row.path}.gz`;
+    const temporary = `${row.path}.partial-${process.pid}.gz`;
+    try {
+      try {
+        await lstat(destination);
+        throw new Error(`legacy_v1_compressed_destination_exists:${row.filename}`);
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+      }
+      await pipeline(
+        createReadStream(row.path),
+        createGzip({ level: 9 }),
+        createWriteStream(temporary, { flags: "wx", mode: 0o600 }),
+      );
+      await proveRowParity(row.path, temporary);
+      const unchanged = (await inventoryLegacyV1Segments(coordRoot)).find(
+        (entry) => entry.path === row.path,
+      );
+      if (
+        !unchanged ||
+        unchanged.bytes !== expected.bytes ||
+        unchanged.digest !== expected.digest
+      ) {
+        throw new Error(`legacy_v1_segment_changed_during_compression:${row.filename}`);
+      }
+      await chmod(temporary, sourceStat.mode & 0o777);
+      await rename(temporary, destination);
+      await rm(row.path);
+      row.action = "compressed";
+      row.reason = "verified gzip replacement preserved every logical row";
+      row.bytes_after = (await lstat(destination)).size;
+      row.path = destination;
+      row.filename = basename(destination);
+    } catch (error) {
+      await rm(temporary, { force: true });
+      throw error;
+    }
+  }
+  return rows;
+}
+
+async function proveRowParity(loose: string, compressed: string): Promise<void> {
+  const left = streamLegacyV1Rows(loose)[Symbol.asyncIterator]();
+  const right = streamLegacyV1Rows(compressed)[Symbol.asyncIterator]();
+  while (true) {
+    const [looseRow, packedRow] = await Promise.all([left.next(), right.next()]);
+    if (looseRow.done || packedRow.done) {
+      if (looseRow.done !== packedRow.done)
+        throw new Error("legacy_v1_compression_row_count_mismatch");
+      return;
+    }
+    if (!looseRow.value.bytes.equals(packedRow.value.bytes)) {
+      throw new Error(`legacy_v1_compression_row_mismatch:${looseRow.value.row_number}`);
+    }
+  }
+}

package/src/core/events/legacy-storage/fence.ts

@@ -0,0 +1,129 @@
+import { createHash } from "node:crypto";
+import { constants, createReadStream } from "node:fs";
+import { lstat, open, readdir, realpath } from "node:fs/promises";
+import { basename, join, relative, resolve } from "node:path";
+import { canonicalJsonV3 } from "../v3/canonical.ts";
+
+export interface LegacyV1HardFence {
+  manifest_version: 1;
+  kind: "v1_hard_path_fence";
+  terminal_archive: string;
+  terminal_digest: `sha256:${string}`;
+}
+
+export interface VerifiedLegacyV1HardFence {
+  fence_directory: string;
+  marker_path: string;
+  terminal_archive_path: string;
+  marker: LegacyV1HardFence;
+}
+
+const MARKER = "V1-SEALED.json";
+const LEGACY_ACTIVE_NAME = ["events", "ndjson"].join(".");
+
+/** Verify the exact read-only V1 path fence and its terminal sealed segment. */
+export async function verifyLegacyV1HardFence(
+  coordRoot: string,
+): Promise<VerifiedLegacyV1HardFence> {
+  const root = resolve(coordRoot);
+  const harnery = join(root, ".harnery");
+  const harneryStat = await lstat(harnery);
+  if (!harneryStat.isDirectory() || harneryStat.isSymbolicLink()) {
+    throw new Error("legacy_v1_harnery_root_invalid");
+  }
+  const harneryReal = await realpath(harnery);
+  const fence = join(harnery, LEGACY_ACTIVE_NAME);
+  let fenceStat: Awaited<ReturnType<typeof lstat>>;
+  try {
+    fenceStat = await lstat(fence);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      throw new Error("legacy_v1_hard_fence_missing");
+    }
+    throw error;
+  }
+  if (!fenceStat.isDirectory() || fenceStat.isSymbolicLink()) {
+    throw new Error("legacy_v1_active_file_present_or_fence_invalid");
+  }
+  if ((fenceStat.mode & 0o222) !== 0) throw new Error("legacy_v1_hard_fence_is_writable");
+  const fenceReal = await realpath(fence);
+  if (relative(harneryReal, fenceReal).startsWith(".."))
+    throw new Error("legacy_v1_hard_fence_escape");
+  const names = (await readdir(fence)).sort();
+  if (names.length !== 1 || names[0] !== MARKER) throw new Error("legacy_v1_hard_fence_not_exact");
+
+  const markerPath = join(fence, MARKER);
+  const markerStat = await lstat(markerPath);
+  if (!markerStat.isFile() || markerStat.isSymbolicLink()) {
+    throw new Error("legacy_v1_hard_fence_marker_invalid");
+  }
+  if ((markerStat.mode & 0o222) !== 0) throw new Error("legacy_v1_hard_fence_marker_writable");
+  if (markerStat.size > 64 * 1024) throw new Error("legacy_v1_hard_fence_marker_too_large");
+  const markerText = await readFileNoFollow(markerPath);
+  const marker = validateFenceMarker(JSON.parse(markerText) as unknown);
+  if (markerText.trim() !== canonicalJsonV3(marker)) {
+    throw new Error("legacy_v1_hard_fence_marker_noncanonical");
+  }
+  const terminalName = marker.terminal_archive.replace(/^\.harnery\//, "");
+  if (!/^events-[0-9]{4}-[0-9]{2}-[0-9]{2}(?:\.[1-9][0-9]*)?\.ndjson$/.test(terminalName)) {
+    throw new Error("legacy_v1_terminal_archive_name_invalid");
+  }
+  const terminalPath = join(harnery, terminalName);
+  const terminalStat = await lstat(terminalPath);
+  if (!terminalStat.isFile() || terminalStat.isSymbolicLink()) {
+    throw new Error("legacy_v1_terminal_archive_invalid");
+  }
+  if ((await hashFile(terminalPath)) !== marker.terminal_digest) {
+    throw new Error("legacy_v1_terminal_archive_digest_mismatch");
+  }
+  return {
+    fence_directory: fence,
+    marker_path: markerPath,
+    terminal_archive_path: terminalPath,
+    marker,
+  };
+}
+
+function validateFenceMarker(value: unknown): LegacyV1HardFence {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("legacy_v1_hard_fence_marker_invalid");
+  }
+  const marker = value as Record<string, unknown>;
+  if (
+    Object.keys(marker).sort().join("\0") !==
+      ["kind", "manifest_version", "terminal_archive", "terminal_digest"].sort().join("\0") ||
+    marker.manifest_version !== 1 ||
+    marker.kind !== "v1_hard_path_fence" ||
+    typeof marker.terminal_archive !== "string" ||
+    typeof marker.terminal_digest !== "string" ||
+    !/^sha256:[0-9a-f]{64}$/.test(marker.terminal_digest)
+  ) {
+    throw new Error("legacy_v1_hard_fence_marker_invalid");
+  }
+  return marker as unknown as LegacyV1HardFence;
+}
+
+async function readFileNoFollow(path: string): Promise<string> {
+  const handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile()) throw new Error("legacy_v1_hard_fence_marker_invalid");
+    return handle.readFile("utf8");
+  } finally {
+    await handle.close();
+  }
+}
+
+async function hashFile(path: string): Promise<`sha256:${string}`> {
+  const hash = createHash("sha256");
+  const handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile()) throw new Error(`legacy_v1_segment_not_regular:${basename(path)}`);
+    const stream = createReadStream(path, { fd: handle.fd, autoClose: false });
+    for await (const current of stream) hash.update(current as Buffer);
+  } finally {
+    await handle.close();
+  }
+  return `sha256:${hash.digest("hex")}`;
+}

package/src/core/events/legacy-storage/index.ts

@@ -0,0 +1,6 @@
+export * from "./canary.ts";
+export * from "./compression.ts";
+export * from "./fence.ts";
+export * from "./inventory.ts";
+export * from "./manifest.ts";
+export * from "./reader.ts";

package/src/core/events/legacy-storage/inventory.ts

@@ -0,0 +1,51 @@
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { lstat, readdir, realpath } from "node:fs/promises";
+import { join, relative, resolve } from "node:path";
+
+export interface LegacyV1SegmentInventoryEntry {
+  filename: string;
+  path: string;
+  bytes: number;
+  digest: `sha256:${string}`;
+  compressed: boolean;
+}
+
+const LEGACY_ACTIVE_NAME = ["events", "ndjson"].join(".");
+
+/** Enumerate all root events*.ndjson* frozen-history candidates, including manual variants. */
+export async function inventoryLegacyV1Segments(
+  coordRoot: string,
+): Promise<LegacyV1SegmentInventoryEntry[]> {
+  const harnery = resolve(coordRoot, ".harnery");
+  const stat = await lstat(harnery);
+  if (!stat.isDirectory() || stat.isSymbolicLink())
+    throw new Error("legacy_v1_inventory_root_invalid");
+  const rootReal = await realpath(harnery);
+  const result: LegacyV1SegmentInventoryEntry[] = [];
+  for (const name of (await readdir(harnery)).sort()) {
+    if (!/^events.*\.ndjson(?:\.gz)?$/.test(name) || name === LEGACY_ACTIVE_NAME) continue;
+    const path = join(harnery, name);
+    const entryStat = await lstat(path);
+    if (!entryStat.isFile() || entryStat.isSymbolicLink()) {
+      throw new Error(`legacy_v1_inventory_segment_invalid:${name}`);
+    }
+    const pathReal = await realpath(path);
+    if (relative(rootReal, pathReal).startsWith(".."))
+      throw new Error("legacy_v1_inventory_escape");
+    result.push({
+      filename: name,
+      path,
+      bytes: entryStat.size,
+      digest: await hashFile(path),
+      compressed: name.endsWith(".gz"),
+    });
+  }
+  return result;
+}
+
+async function hashFile(path: string): Promise<`sha256:${string}`> {
+  const hash = createHash("sha256");
+  for await (const current of createReadStream(path)) hash.update(current as Buffer);
+  return `sha256:${hash.digest("hex")}`;
+}