@elpapi42/pi-fleet 0.1.0-beta.2 → 0.1.0-beta.5

package/CHANGELOG.md

@@ -12,6 +12,47 @@
 - Added a nightly reliability workflow and an isolated soak suite covering 500 concurrent ordered sends and 100 name lifecycle cycles.
 - Reject invalid UTF-8 in stdin and Pi RPC stdout instead of silently replacing bytes at either protocol boundary.
 
+## 0.1.0-beta.5 — 2026-07-20
+
+Release-pipeline reliability follow-up; includes the beta.4 receive and argument-validation fixes.
+
+### Fixed
+
+- On Linux, process-group cleanup now treats zombie processes as exited by inspecting procfs instead of relying only on signal probes. This prevents conservative cleanup waits and CI failures when an orphaned descendant is awaiting reaping.
+- Pi shutdown now waits for the child-process exit callback and coordinator transition before reporting completion, preventing a status read from briefly retaining `resident` after an idle release.
+- Repeated the process-tree and real-Pi process suites five times locally before tagging after beta.4's publish workflow exposed the runner-specific zombie behavior.
+
+## 0.1.0-beta.4 — 2026-07-20
+
+Manual edge-case testing fix. No intentional CLI contract change.
+
+### Fixed
+
+- Prevented `receive --timeout 0` from rejecting an idle waiter before a handler was attached and terminating the runtime with an unhandled `Receive cancelled` rejection.
+- Added explicit coordinator work tracking so promptless/repeated idle polling returns `no_response` or the latest response immediately, while managed work still waits for Pi settlement.
+- Closed the abort-listener registration race and added regression coverage for timeout, disconnect, repeated receive, and settlement ordering.
+- Return durable `invalid_arguments` errors for rejected Pi startup/positional arguments instead of a generic `internal_error`.
+
+### Manual validation
+
+- Direct isolated lifecycle, timeout, repeated receive, raw watch, session mutation, concurrent startup/send, Pi/runtime crash recovery, capacity, and session-preservation scenarios passed against the beta.4 source build.
+- Fresh-registry operational validation remains enforced by the tag workflow after publication.
+
+## 0.1.0-beta.3 — 2026-07-20
+
+Reliability fix for fresh global npm installations. No intentional CLI or agent-lifecycle contract change.
+
+### Fixed
+
+- Replaced the invalid assumption that npm recreates CI's byte-identical `node_modules` tree. Schema-3 runtime manifests retain exact hashes for Fleet-owned files, validate direct dependency name/version, derive the observed dependency-closure hash at materialization, and prove source-before, staged, and source-after closure equality before activation.
+- Made immutable runtime release paths closure-specific, so different legitimate npm dependency layouts do not collide.
+- Strengthened package testing to mutate a fresh installed dependency tree, require an operational `list`, remove the npm installation, stop the runtime, and restart through the materialized release.
+
+### Installation scope
+
+- The documented global npm installation layout, where dependencies are package-local, is supported. Arbitrarily hoisted local-prefix, pnpm, and unusual `npx` dependency layouts are not yet supported.
+- The tag workflow now performs a fresh registry-install operational `list` smoke after publishing. That smoke is a release gate and has not yet run for beta.3.
+
 ## 0.1.0-beta.2 — 2026-07-20
 
 Reliability-focused beta maintenance release. No intentional product-contract changes.

package/README.md

@@ -8,7 +8,7 @@ create · send · receive · status · list · watch · destroy
 
 Fleet keeps a Pi process resident when possible, restores it from the same native Pi session when absent, accepts repeated steering input, and returns the latest assistant message after Pi becomes idle. Pi sessions remain under your control: Fleet references them but never copies or deletes them.
 
-> **Beta:** `0.1.0-beta.2` is validated on Linux x64 with Pi `0.80.10`, including deterministic fault, recovery, package-compatibility, and resource-stability testing. Actual logout/reboot recovery, macOS launchd/containment, automatic upgrades, and public service-management UX are not yet release-validated.
+> **Beta:** `0.1.0-beta.5` has passed deterministic Linux x64 fault, recovery, package, compatibility, and resource-stability tests with Pi `0.80.10`. Its tag workflow additionally requires a fresh registry-install operational smoke after publication; that external check has not yet run for beta.3. Actual logout/reboot recovery, macOS launchd/containment, automatic upgrades, and public service-management UX are not yet release-validated.
 
 ## Install
 
@@ -173,7 +173,7 @@ Do not include API keys, message contents, session contents, or private paths un
 
 ## Beta limitations
 
-- Current deterministic reliability and package validation covers Linux x64 only.
+- Current deterministic reliability and documented global-install package validation cover Linux x64 only. Arbitrarily hoisted local-prefix, pnpm, and unusual `npx` dependency layouts are not yet supported.
 - Actual logout and host reboot recovery remain unvalidated.
 - launchd and macOS descendant containment remain unvalidated.
 - Real disk-exhaustion behavior and multi-hour resource growth remain unvalidated; bounded SQLite and in-process resource tests are covered.

package/dist/cli-meta.json

@@ -423,7 +423,7 @@
       "format": "esm"
     },
     "src/platform/install/tree-integrity.ts": {
-      "bytes": 2225,
+      "bytes": 2529,
       "imports": [
         {
           "path": "node:crypto",
@@ -444,7 +444,7 @@
       "format": "esm"
     },
     "src/platform/install/runtime-release.ts": {
-      "bytes": 9583,
+      "bytes": 15742,
       "imports": [
         {
           "path": "node:crypto",
@@ -593,7 +593,7 @@
       "imports": [],
       "exports": [],
       "inputs": {},
-      "bytes": 260315
+      "bytes": 270001
     },
     "dist/cli.mjs": {
       "imports": [
@@ -828,16 +828,16 @@
           "bytesInOutput": 4658
         },
         "src/platform/install/runtime-release.ts": {
-          "bytesInOutput": 8505
+          "bytesInOutput": 13651
         },
         "src/platform/install/tree-integrity.ts": {
-          "bytesInOutput": 1879
+          "bytesInOutput": 2182
         },
         "src/platform/shared/paths.ts": {
           "bytesInOutput": 1191
         }
       },
-      "bytes": 144920
+      "bytes": 150369
     }
   }
 }

package/dist/cli.mjs

@@ -3385,7 +3385,7 @@ function splitArgv(argv) {
 
 // src/shared/product-identity.ts
 var PRODUCT_BINARY = "pifleet";
-var PRODUCT_VERSION = "0.1.0-beta.2";
+var PRODUCT_VERSION = "0.1.0-beta.5";
 
 // src/cli/commands/create.ts
 import { resolve } from "node:path";
@@ -3907,12 +3907,12 @@ import { promisify } from "node:util";
 
 // src/platform/install/runtime-release.ts
 import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
-import { chmod, cp, lstat as lstat2, mkdir, readFile as readFile2, rename, rm } from "node:fs/promises";
+import { chmod, cp, lstat as lstat2, mkdir, readFile as readFile2, rename, rm, writeFile } from "node:fs/promises";
 import { join as join2, posix, resolve as resolve3, sep as sep2 } from "node:path";
 
 // src/platform/install/tree-integrity.ts
 import { createHash } from "node:crypto";
-import { lstat, readFile, readdir, stat } from "node:fs/promises";
+import { lstat, readFile, readdir, realpath, stat } from "node:fs/promises";
 import { join, relative, resolve as resolve2, sep } from "node:path";
 async function hashDirectoryTree(root, manifestPath) {
   const resolvedRoot = resolve2(root);
@@ -3952,6 +3952,14 @@ async function collectFiles(root, directory) {
     if (!info.isFile()) {
       throw new Error(`Runtime dependency tree contains an unsupported entry: ${absolutePath}`);
     }
+    if (linkInfo.isSymbolicLink()) {
+      const target = await realpath(absolutePath);
+      if (target !== root && !target.startsWith(`${root}${sep}`)) {
+        throw new Error(
+          `Runtime dependency tree contains an external file symlink: ${absolutePath}`
+        );
+      }
+    }
     const relativePath = relative(root, absolutePath).split(sep).join("/");
     if (relativePath.length === 0 || relativePath.startsWith("../")) {
       throw new Error(`Runtime dependency path escapes its root: ${absolutePath}`);
@@ -3970,19 +3978,33 @@ var requiredRuntimeArtifacts = /* @__PURE__ */ new Set([
   "dist/runtime.mjs",
   "dist/sqlite-worker.mjs"
 ]);
+var dependencyTreePath = "node_modules";
 async function materializeRuntime(options) {
   const sourceRoot = resolve3(options.sourceRoot);
   const manifestBytes = await readFile2(join2(sourceRoot, "dist", "runtime-manifest.json"));
-  const manifest = await parseRuntimeManifest(manifestBytes, sourceRoot);
-  await verifyRuntime(sourceRoot, manifest);
+  const sourceManifest = await parseRuntimeManifest(manifestBytes, sourceRoot);
+  if (sourceManifest.closure !== void 0) {
+    await verifyRuntime(sourceRoot);
+    return sourceRoot;
+  }
+  await verifyRuntimeFiles(sourceRoot, sourceManifest);
+  await verifyDependencyIdentities(sourceRoot, sourceManifest.dependencies);
+  const sourceTreeRoot = resolveInside(sourceRoot, dependencyTreePath);
+  const sourceTreeBefore = await hashDirectoryTree(sourceTreeRoot, dependencyTreePath);
+  const sourceManifestSha256 = createHash2("sha256").update(manifestBytes).digest("hex");
+  const materializedManifest = {
+    ...sourceManifest,
+    closure: { sourceManifestSha256, tree: sourceTreeBefore }
+  };
+  const materializedManifestBytes = serializeManifest(materializedManifest);
+  const closureHash = createHash2("sha256").update(sourceManifestSha256).update("\0").update(JSON.stringify(sourceTreeBefore)).digest("hex").slice(0, 16);
   const applicationRoot = resolve3(options.applicationRoot);
   await ensurePrivateDirectory(applicationRoot);
-  const manifestHash = createHash2("sha256").update(manifestBytes).digest("hex").slice(0, 16);
   const releasesRoot = join2(applicationRoot, "releases");
   await ensurePrivateDirectory(releasesRoot);
-  const destination = join2(releasesRoot, `${manifest.package.version}-${manifestHash}`);
+  const destination = join2(releasesRoot, `${sourceManifest.package.version}-${closureHash}`);
   if (await pathExists(destination)) {
-    await verifyRuntime(destination, manifest);
+    await verifyExpectedRuntime(destination, materializedManifest, materializedManifestBytes);
     return destination;
   }
   const staging = join2(releasesRoot, `.staging-${randomUUID2()}`);
@@ -3992,36 +4014,73 @@ async function materializeRuntime(options) {
       recursive: true,
       dereference: true
     });
-    await cp(join2(sourceRoot, "bin"), join2(staging, "bin"), { recursive: true, dereference: true });
+    await cp(join2(sourceRoot, "bin"), join2(staging, "bin"), {
+      recursive: true,
+      dereference: true
+    });
     await cp(join2(sourceRoot, "package.json"), join2(staging, "package.json"));
-    for (const tree of manifest.trees) {
-      const source = resolveInside(sourceRoot, tree.path);
-      const destination2 = resolveInside(staging, tree.path);
-      await mkdir(resolve3(destination2, ".."), { recursive: true, mode: 448 });
-      await cp(source, destination2, { recursive: true, dereference: true });
-    }
-    await verifyRuntime(staging, manifest);
+    await cp(sourceTreeRoot, join2(staging, dependencyTreePath), {
+      recursive: true,
+      dereference: true
+    });
+    await options.hooks?.afterDependencyCopy?.();
+    const stagedTree = await hashDirectoryTree(
+      join2(staging, dependencyTreePath),
+      dependencyTreePath
+    );
+    assertSameTree(sourceTreeBefore, stagedTree, "copied dependency closure");
+    const sourceTreeAfter = await hashDirectoryTree(sourceTreeRoot, dependencyTreePath);
+    assertSameTree(sourceTreeBefore, sourceTreeAfter, "source dependency closure");
+    await writeFile(join2(staging, "dist", "runtime-manifest.json"), materializedManifestBytes);
+    await verifyExpectedRuntime(staging, materializedManifest, materializedManifestBytes);
     await chmod(staging, 448);
     try {
       await rename(staging, destination);
     } catch (error) {
       if (!isDestinationRace(error) || !await pathExists(destination)) throw error;
-      await verifyRuntime(destination, manifest);
+      await verifyExpectedRuntime(destination, materializedManifest, materializedManifestBytes);
     }
     return destination;
   } finally {
     await rm(staging, { recursive: true, force: true });
   }
 }
-async function verifyRuntime(root, manifest) {
+async function verifyRuntime(root) {
   const resolvedRoot = resolve3(root);
-  const expected = manifest ?? await parseRuntimeManifest(
-    await readFile2(join2(resolvedRoot, "dist", "runtime-manifest.json")),
-    resolvedRoot
+  const manifestBytes = await readFile2(join2(resolvedRoot, "dist", "runtime-manifest.json"));
+  const manifest = await parseRuntimeManifest(manifestBytes, resolvedRoot);
+  if (manifest.closure === void 0) {
+    throw new Error("Runtime release manifest is missing its materialized closure");
+  }
+  await verifyRuntimeFiles(resolvedRoot, manifest);
+  await verifyDependencyIdentities(resolvedRoot, manifest.dependencies);
+  const actualTree = await hashDirectoryTree(
+    resolveInside(resolvedRoot, dependencyTreePath),
+    dependencyTreePath
+  );
+  assertSameTree(manifest.closure.tree, actualTree, "materialized dependency closure");
+}
+async function verifyExpectedRuntime(root, expected, expectedBytes) {
+  const manifestPath = join2(root, "dist", "runtime-manifest.json");
+  const actualBytes = await readFile2(manifestPath);
+  if (!actualBytes.equals(expectedBytes)) {
+    throw new Error("Materialized runtime manifest does not match the expected closure");
+  }
+  const actual = await parseRuntimeManifest(actualBytes, root);
+  if (actual.closure === void 0 || expected.closure === void 0) {
+    throw new Error("Materialized runtime manifest is missing its closure");
+  }
+  await verifyRuntimeFiles(root, actual);
+  await verifyDependencyIdentities(root, actual.dependencies);
+  const actualTree = await hashDirectoryTree(
+    resolveInside(root, dependencyTreePath),
+    dependencyTreePath
   );
-  if (manifest !== void 0) await validateRuntimeManifest(manifest, resolvedRoot);
-  for (const file of expected.files) {
-    const path2 = resolveInside(resolvedRoot, file.path);
+  assertSameTree(expected.closure.tree, actualTree, "materialized dependency closure");
+}
+async function verifyRuntimeFiles(root, manifest) {
+  for (const file of manifest.files) {
+    const path2 = resolveInside(root, file.path);
     const info = await lstat2(path2);
     if (info.isSymbolicLink()) {
       throw new Error(`Runtime artifact ${file.path} must not be a symbolic link`);
@@ -4034,11 +4093,27 @@ async function verifyRuntime(root, manifest) {
       throw new Error(`Runtime artifact ${file.path} failed verification`);
     }
   }
-  for (const expectedTree of expected.trees) {
-    const treeRoot = resolveInside(resolvedRoot, expectedTree.path);
-    const actualTree = await hashDirectoryTree(treeRoot, expectedTree.path);
-    if (actualTree.files !== expectedTree.files || actualTree.bytes !== expectedTree.bytes || actualTree.sha256 !== expectedTree.sha256) {
-      throw new Error(`Runtime dependency tree ${expectedTree.path} failed verification`);
+}
+async function verifyDependencyIdentities(root, dependencies) {
+  const nodeModules = resolveInside(root, dependencyTreePath);
+  const modulesInfo = await lstat2(nodeModules);
+  if (!modulesInfo.isDirectory() || modulesInfo.isSymbolicLink()) {
+    throw new Error("Runtime dependency closure must be a regular directory");
+  }
+  for (const dependency of dependencies) {
+    const packageRoot = resolveInside(root, dependency.path);
+    const packageInfo = await lstat2(packageRoot);
+    if (!packageInfo.isDirectory() || packageInfo.isSymbolicLink()) {
+      throw new Error(`Runtime dependency ${dependency.name} must be a regular directory`);
+    }
+    const packageJsonPath = join2(packageRoot, "package.json");
+    const packageJsonInfo = await lstat2(packageJsonPath);
+    if (!packageJsonInfo.isFile() || packageJsonInfo.isSymbolicLink()) {
+      throw new Error(`Runtime dependency ${dependency.name} has an unsafe package.json`);
+    }
+    const identity = await readPackageMetadata(packageRoot);
+    if (identity.name !== dependency.name || identity.version !== dependency.version) {
+      throw new Error(`Runtime dependency ${dependency.name} has an unexpected identity`);
     }
   }
 }
@@ -4053,17 +4128,17 @@ async function parseRuntimeManifest(bytes, root) {
   return candidate;
 }
 async function validateRuntimeManifest(candidate, root) {
-  if (!isRecord2(candidate) || candidate.schemaVersion !== 2) {
+  if (!isRecord2(candidate) || candidate.schemaVersion !== 3) {
     throw new Error("Runtime manifest has an unsupported schema version");
   }
-  if (!isRecord2(candidate.package) || typeof candidate.package.name !== "string" || typeof candidate.package.version !== "string") {
+  if (!isRecord2(candidate.package) || typeof candidate.package.name !== "string" || typeof candidate.package.version !== "string" || typeof candidate.managedPi !== "string") {
     throw new Error("Runtime manifest has an invalid package identity");
   }
-  const packageIdentity = await readPackageIdentity(root);
-  if (candidate.package.name !== packageIdentity.name || candidate.package.version !== packageIdentity.version) {
+  const packageMetadata = await readPackageMetadata(root);
+  if (candidate.package.name !== packageMetadata.name || candidate.package.version !== packageMetadata.version) {
     throw new Error("Runtime manifest package identity does not match package.json");
   }
-  if (!Array.isArray(candidate.files) || !Array.isArray(candidate.trees)) {
+  if (!Array.isArray(candidate.files) || !Array.isArray(candidate.dependencies)) {
     throw new Error("Runtime manifest has invalid artifact lists");
   }
   const filePaths = /* @__PURE__ */ new Set();
@@ -4071,8 +4146,9 @@ async function validateRuntimeManifest(candidate, root) {
     if (!isRecord2(file) || !isManifestPath(file.path) || !isValidSize(file.bytes) || !isSha256(file.sha256)) {
       throw new Error("Runtime manifest contains an invalid artifact");
     }
-    if (filePaths.has(file.path))
+    if (filePaths.has(file.path)) {
       throw new Error(`Runtime manifest has duplicate path ${file.path}`);
+    }
     filePaths.add(file.path);
   }
   for (const required of requiredRuntimeArtifacts) {
@@ -4080,37 +4156,63 @@ async function validateRuntimeManifest(candidate, root) {
       throw new Error(`Runtime manifest is missing required artifact ${required}`);
     }
   }
-  const treePaths = /* @__PURE__ */ new Set();
-  for (const tree of candidate.trees) {
-    if (!isRecord2(tree) || !isManifestPath(tree.path) || !isValidSize(tree.files) || !isValidSize(tree.bytes) || !isSha256(tree.sha256)) {
-      throw new Error("Runtime manifest contains an invalid dependency tree");
+  const dependencyPaths = /* @__PURE__ */ new Set();
+  const dependencyNames = /* @__PURE__ */ new Set();
+  for (const dependency of candidate.dependencies) {
+    if (!isRecord2(dependency) || !isManifestPath(dependency.path) || typeof dependency.name !== "string" || dependency.name.length === 0 || typeof dependency.version !== "string" || dependency.version.length === 0 || dependency.path !== `node_modules/${dependency.name}`) {
+      throw new Error("Runtime manifest contains an invalid dependency declaration");
     }
-    if (treePaths.has(tree.path))
-      throw new Error(`Runtime manifest has duplicate path ${tree.path}`);
-    treePaths.add(tree.path);
-  }
-  const allPaths = [...filePaths, ...treePaths];
-  for (let index = 0; index < allPaths.length; index += 1) {
-    for (let other = index + 1; other < allPaths.length; other += 1) {
-      const left = allPaths[index];
-      const right = allPaths[other];
-      if (left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`)) {
-        throw new Error(`Runtime manifest has overlapping paths ${left} and ${right}`);
+    if (dependencyPaths.has(dependency.path) || dependencyNames.has(dependency.name)) {
+      throw new Error(`Runtime manifest has duplicate dependency ${dependency.name}`);
+    }
+    dependencyPaths.add(dependency.path);
+    dependencyNames.add(dependency.name);
+  }
+  const expectedDependencies = packageMetadata.dependencies;
+  if (dependencyNames.size !== Object.keys(expectedDependencies).length || [...dependencyNames].some(
+    (name) => expectedDependencies[name] !== candidate.dependencies.find(
+      (dependency) => dependency.name === name
+    )?.version
+  )) {
+    throw new Error("Runtime manifest dependencies do not match package.json");
+  }
+  for (const filePath of filePaths) {
+    for (const dependencyPath of dependencyPaths) {
+      if (filePath === dependencyPath || filePath.startsWith(`${dependencyPath}/`) || dependencyPath.startsWith(`${filePath}/`)) {
+        throw new Error(`Runtime manifest has overlapping paths ${filePath} and ${dependencyPath}`);
       }
     }
   }
+  if (candidate.closure !== void 0) {
+    if (!isRecord2(candidate.closure) || !isSha256(candidate.closure.sourceManifestSha256) || !isTreeIntegrity(candidate.closure.tree) || candidate.closure.tree.path !== dependencyTreePath) {
+      throw new Error("Runtime manifest contains an invalid materialized closure");
+    }
+  }
 }
-async function readPackageIdentity(root) {
+async function readPackageMetadata(root) {
   let candidate;
   try {
     candidate = JSON.parse(await readFile2(join2(root, "package.json"), "utf8"));
   } catch {
     throw new Error("Runtime package.json is not valid JSON");
   }
-  if (!isRecord2(candidate) || typeof candidate.name !== "string" || typeof candidate.version !== "string") {
-    throw new Error("Runtime package.json has an invalid identity");
+  if (!isRecord2(candidate) || typeof candidate.name !== "string" || typeof candidate.version !== "string" || candidate.dependencies !== void 0 && !isRecord2(candidate.dependencies) || isRecord2(candidate.dependencies) && Object.values(candidate.dependencies).some((version) => typeof version !== "string")) {
+    throw new Error("Runtime package.json has invalid package metadata");
+  }
+  return {
+    name: candidate.name,
+    version: candidate.version,
+    dependencies: isRecord2(candidate.dependencies) ? candidate.dependencies : {}
+  };
+}
+function serializeManifest(manifest) {
+  return Buffer.from(`${JSON.stringify(manifest, null, 2)}
+`);
+}
+function assertSameTree(expected, actual, label) {
+  if (expected.path !== actual.path || expected.files !== actual.files || expected.bytes !== actual.bytes || expected.sha256 !== actual.sha256) {
+    throw new Error(`Runtime ${label} changed during materialization`);
   }
-  return { name: candidate.name, version: candidate.version };
 }
 function resolveInside(root, path2) {
   if (!isManifestPath(path2)) throw new Error(`Runtime manifest contains an unsafe path ${path2}`);
@@ -4132,6 +4234,9 @@ function isValidSize(value) {
 function isSha256(value) {
   return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
 }
+function isTreeIntegrity(value) {
+  return isRecord2(value) && isManifestPath(value.path) && isValidSize(value.files) && isValidSize(value.bytes) && isSha256(value.sha256);
+}
 function isDestinationRace(error) {
   const code = error.code;
   return code === "EEXIST" || code === "ENOTEMPTY";