@moretea-labs/forge 1.8.0 → 1.8.1

package/src/runtime/root/ownership.ts

@@ -10,13 +10,28 @@ import {
 } from 'fs';
 import { dirname, join } from 'path';
 import { resolveControllerHome } from '../../cli/repositories/controller-home';
-import { isProcessAlive } from '../shared/process-tree';
+import { isProcessAlive, terminateProcessTree, type ProcessTreeTerminationResult } from '../shared/process-tree';
+import { defaultProcessIdentityProbe, executableFingerprint, processIdentityMatches } from '../shared/process-identity';
 
 export interface RuntimeOwnerRecord {
-  schemaVersion: 1;
+  schemaVersion: 1 | 2;
   runtimeInstanceId: string;
   pid: number;
   acquiredAt: string;
+  /** Monotonic Controller-Home writer epoch. Schema v1 owners predate it. */
+  fencingGeneration?: number;
+  /** Optional OS-process identity evidence used only for bounded crash recovery. */
+  processStartTime?: string;
+  executableFingerprint?: string;
+}
+
+export interface RuntimeIncarnationRecord {
+  schemaVersion: 1;
+  controllerHome: string;
+  runtimeInstanceId: string;
+  pid: number;
+  fencingGeneration: number;
+  activatedAt: string;
 }
 
 export interface RuntimeOwnershipHandle {
@@ -28,11 +43,18 @@ export function runtimeOwnerPath(controllerHome: string): string {
   return join(resolveControllerHome(controllerHome), 'runtime', 'active-runtime-owner.json');
 }
 
+export function runtimeIncarnationPath(controllerHome: string): string {
+  return join(resolveControllerHome(controllerHome), 'runtime', 'runtime-incarnation.json');
+}
+
 function readOwnerPath(path: string): RuntimeOwnerRecord | undefined {
   if (!existsSync(path)) return undefined;
   try {
     const value = JSON.parse(readFileSync(path, 'utf8')) as RuntimeOwnerRecord;
-    if (value.schemaVersion !== 1 || !value.runtimeInstanceId || !Number.isInteger(value.pid)) return undefined;
+    if ((value.schemaVersion !== 1 && value.schemaVersion !== 2) || !value.runtimeInstanceId || !Number.isInteger(value.pid)) return undefined;
+    if (value.schemaVersion === 2 && (!Number.isInteger(value.fencingGeneration) || value.fencingGeneration! < 1)) return undefined;
+    if ((value.processStartTime === undefined) !== (value.executableFingerprint === undefined)) return undefined;
+    if (value.processStartTime !== undefined && (!value.processStartTime.trim() || !value.executableFingerprint?.trim())) return undefined;
     return value;
   } catch {
     return undefined;
@@ -43,6 +65,208 @@ export function readRuntimeOwner(controllerHome: string): RuntimeOwnerRecord | u
   return readOwnerPath(runtimeOwnerPath(controllerHome));
 }
 
+export function readRuntimeIncarnation(controllerHome: string): RuntimeIncarnationRecord | undefined {
+  const path = runtimeIncarnationPath(controllerHome);
+  if (!existsSync(path)) return undefined;
+  try {
+    const value = JSON.parse(readFileSync(path, 'utf8')) as RuntimeIncarnationRecord;
+    if (
+      value.schemaVersion !== 1
+      || resolveControllerHome(value.controllerHome) !== resolveControllerHome(controllerHome)
+      || !value.runtimeInstanceId
+      || !Number.isInteger(value.pid)
+      || !Number.isInteger(value.fencingGeneration)
+      || value.fencingGeneration < 1
+      || !Number.isFinite(Date.parse(value.activatedAt))
+    ) return undefined;
+    return value;
+  } catch {
+    return undefined;
+  }
+}
+
+function nextFencingGeneration(controllerHome: string, minimum = 1): number {
+  const incarnationGeneration = readRuntimeIncarnation(controllerHome)?.fencingGeneration ?? 0;
+  const ownerGeneration = readRuntimeOwner(controllerHome)?.fencingGeneration ?? 0;
+  return Math.max(minimum - 1, incarnationGeneration, ownerGeneration) + 1;
+}
+
+function writeRuntimeIncarnation(record: RuntimeIncarnationRecord): void {
+  const path = runtimeIncarnationPath(record.controllerHome);
+  const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync(temporary, `${JSON.stringify(record, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+  renameSync(temporary, path);
+}
+
+
+export interface RuntimeOwnershipInspection {
+  owner?: RuntimeOwnerRecord;
+  incarnation?: RuntimeIncarnationRecord;
+  ownerAlive: boolean;
+  incarnationAlive: boolean;
+  coherent: boolean;
+}
+
+export function inspectRuntimeOwnership(controllerHome: string): RuntimeOwnershipInspection {
+  const owner = readRuntimeOwner(controllerHome);
+  const incarnation = readRuntimeIncarnation(controllerHome);
+  const coherent = Boolean(
+    owner
+    && incarnation
+    && owner.runtimeInstanceId === incarnation.runtimeInstanceId
+    && owner.pid === incarnation.pid
+    && (owner.fencingGeneration ?? incarnation.fencingGeneration) === incarnation.fencingGeneration,
+  );
+  // Schema-v2 owners carry OS-process identity. Once present, raw PID liveness
+  // is insufficient because a stopped Runtime PID may be reused by another
+  // process before Recovery reconciles durable ownership.
+  const ownerAlive = Boolean(owner && (
+    owner.processStartTime && owner.executableFingerprint
+      ? runtimeOwnerProcessIdentityMatches(owner)
+      : isProcessAlive(owner.pid)
+  ));
+  // A coherent incarnation is the same Runtime owner epoch, so inherit the
+  // stronger owner identity result instead of re-introducing PID-only liveness.
+  // Incarnation-only legacy evidence remains conservative because it has no
+  // independent process identity fields.
+  const incarnationAlive = Boolean(incarnation && (
+    coherent
+      ? ownerAlive
+      : isProcessAlive(incarnation.pid)
+  ));
+  return { owner, incarnation, ownerAlive, incarnationAlive, coherent };
+}
+
+export function runtimeOwnerProcessIdentityMatches(record: RuntimeOwnerRecord | undefined): boolean {
+  if (!record?.processStartTime || !record.executableFingerprint) return false;
+  return processIdentityMatches({
+    pid: record.pid,
+    processStartTime: record.processStartTime,
+    executableFingerprint: record.executableFingerprint,
+  }, record.pid).matches;
+}
+
+/**
+ * Recovery calls this only after the service manager and Runtime listener have
+ * been proven stopped. It never kills a live process. Dead owner evidence is
+ * renamed, not discarded, so fencing generations and forensic evidence survive.
+ */
+export function reconcileStoppedRuntimeOwnership(controllerHome: string): {
+  ok: boolean;
+  changed: boolean;
+  detail: string;
+  inspection: RuntimeOwnershipInspection;
+  staleOwnerPath?: string;
+} {
+  const inspection = inspectRuntimeOwnership(controllerHome);
+  if (inspection.ownerAlive || inspection.incarnationAlive) {
+    return {
+      ok: false,
+      changed: false,
+      detail: 'RUNTIME_OWNERSHIP_STILL_LIVE',
+      inspection,
+    };
+  }
+  const ownerPath = runtimeOwnerPath(controllerHome);
+  if (!inspection.owner || !existsSync(ownerPath)) {
+    return {
+      ok: true,
+      changed: false,
+      detail: 'Runtime ownership is already quiescent',
+      inspection,
+    };
+  }
+  const staleOwnerPath = `${ownerPath}.stale-${Date.now()}`;
+  renameSync(ownerPath, staleOwnerPath);
+  return {
+    ok: true,
+    changed: true,
+    detail: 'dead Runtime owner evidence was fenced out after service shutdown',
+    inspection,
+    staleOwnerPath,
+  };
+}
+
+
+export async function terminateVerifiedRuntimeOwner(
+  controllerHome: string,
+  expectedOwner?: RuntimeOwnerRecord | null,
+): Promise<{
+  ok: boolean;
+  attempted: boolean;
+  detail: string;
+  owner?: RuntimeOwnerRecord;
+  termination?: ProcessTreeTerminationResult;
+}> {
+  const owner = readRuntimeOwner(controllerHome);
+  if (expectedOwner) {
+    if (!owner) {
+      return {
+        ok: true,
+        attempted: false,
+        detail: 'Runtime owner disappeared during stop',
+        owner: expectedOwner,
+      };
+    }
+    if (
+      owner.pid !== expectedOwner.pid
+      || owner.runtimeInstanceId !== expectedOwner.runtimeInstanceId
+      || owner.fencingGeneration !== expectedOwner.fencingGeneration
+      || owner.processStartTime !== expectedOwner.processStartTime
+      || owner.executableFingerprint !== expectedOwner.executableFingerprint
+    ) {
+      return {
+        ok: false,
+        attempted: false,
+        detail: 'RUNTIME_OWNER_CHANGED_DURING_STOP',
+        owner,
+      };
+    }
+  } else if (owner) {
+    return {
+      ok: false,
+      attempted: false,
+      detail: 'RUNTIME_OWNER_APPEARED_DURING_STOP',
+      owner,
+    };
+  }
+  if (!owner) return { ok: true, attempted: false, detail: 'Runtime owner is already absent' };
+  if (!isProcessAlive(owner.pid)) {
+    return { ok: true, attempted: false, detail: 'Runtime owner process is already dead', owner };
+  }
+  if (!owner.processStartTime || !owner.executableFingerprint) {
+    return {
+      ok: false,
+      attempted: false,
+      detail: 'RUNTIME_OWNER_IDENTITY_EVIDENCE_MISSING',
+      owner,
+    };
+  }
+  if (!runtimeOwnerProcessIdentityMatches(owner)) {
+    return {
+      ok: false,
+      attempted: false,
+      detail: 'RUNTIME_OWNER_IDENTITY_CHANGED',
+      owner,
+    };
+  }
+  const termination = await terminateProcessTree(owner.pid, {
+    gracePeriodMs: 1_500,
+    killAfterMs: 5_000,
+    pollIntervalMs: 50,
+  });
+  const exited = termination.exited && !isProcessAlive(owner.pid);
+  return {
+    ok: exited,
+    attempted: true,
+    detail: exited
+      ? 'verified orphan Runtime owner process tree terminated after service shutdown'
+      : `verified orphan Runtime owner did not fully exit; remaining pids=${termination.remainingPids.join(',')}`,
+    owner,
+    termination,
+  };
+}
+
 export function acquireRuntimeOwnership(
   controllerHome: string,
   runtimeInstanceId: string,
@@ -51,14 +275,23 @@ export function acquireRuntimeOwnership(
   if (!runtimeInstanceId.trim()) throw new Error('RUNTIME_INSTANCE_ID_REQUIRED');
   const path = runtimeOwnerPath(controllerHome);
   mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-  const record: RuntimeOwnerRecord = {
-    schemaVersion: 1,
-    runtimeInstanceId,
-    pid: process.pid,
-    acquiredAt: now(),
-  };
+  let minimumGeneration = nextFencingGeneration(controllerHome);
 
   for (let attempt = 0; attempt < 3; attempt += 1) {
+    const generation = nextFencingGeneration(controllerHome, minimumGeneration);
+    const processStartTime = defaultProcessIdentityProbe.startTime(process.pid);
+    const processCommand = defaultProcessIdentityProbe.command(process.pid);
+    const record: RuntimeOwnerRecord = {
+      schemaVersion: 2,
+      runtimeInstanceId,
+      pid: process.pid,
+      acquiredAt: now(),
+      fencingGeneration: generation,
+      ...(processStartTime && processCommand ? {
+        processStartTime,
+        executableFingerprint: executableFingerprint(processCommand),
+      } : {}),
+    };
     try {
       const fd = openSync(path, 'wx', 0o600);
       try {
@@ -66,6 +299,19 @@ export function acquireRuntimeOwnership(
       } finally {
         closeSync(fd);
       }
+      try {
+        writeRuntimeIncarnation({
+          schemaVersion: 1,
+          controllerHome: resolveControllerHome(controllerHome),
+          runtimeInstanceId,
+          pid: process.pid,
+          fencingGeneration: generation,
+          activatedAt: record.acquiredAt,
+        });
+      } catch (writeError) {
+        try { unlinkSync(path); } catch { /* ownership did not become usable */ }
+        throw writeError;
+      }
       return {
         record,
         release: () => {
@@ -84,6 +330,12 @@ export function acquireRuntimeOwnership(
           `RUNTIME_OWNERSHIP_CONFLICT: controller home is owned by ${current.runtimeInstanceId} pid=${current.pid}`,
         );
       }
+      minimumGeneration = Math.max(
+        minimumGeneration,
+        generation + 1,
+        (current?.fencingGeneration ?? 0) + 1,
+        (readRuntimeIncarnation(controllerHome)?.fencingGeneration ?? 0) + 1,
+      );
       const stalePath = `${path}.stale-${Date.now()}-${attempt}`;
       try { renameSync(path, stalePath); } catch (renameError) {
         if ((renameError as NodeJS.ErrnoException).code !== 'ENOENT') throw renameError;

package/src/runtime/root/package-connector-service.ts

@@ -1,10 +1,12 @@
 import { createHash } from 'crypto';
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'fs';
+import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
 import { basename, dirname, join, resolve } from 'path';
 import { loadMcpServiceLocalConfig } from '../../cli/mcp/auth';
+import { runtimeAuthorityFreeEnvironment } from '../shared/process-environment';
 import type { PackageRuntimeRelease } from './package-runtime-release';
 import { createPlatformServiceManagerHost, platformLaunchdInstalledPath, type PlatformServiceManagerHost, type SystemdUserUnitInput } from '../platform/service-manager';
+import { forgeConnectorPersistentServiceLabel } from '../platform/service-inventory';
 
 export interface PackageConnectorServicePaths {
   label: string;
@@ -14,9 +16,13 @@ export interface PackageConnectorServicePaths {
   stdoutPath: string;
   stderrPath: string;
   authorityPath: string;
+  activeEntrypointPath: string;
 }
 
-export type PackageConnectorReleaseBinding = Pick<PackageRuntimeRelease, 'releaseId' | 'releaseRoot' | 'packageRoot'>;
+export type PackageConnectorReleaseBinding = Pick<PackageRuntimeRelease, 'releaseId' | 'releaseRoot' | 'packageRoot'> & {
+  connectorEntrypoint?: 'forge-mcp-gateway';
+  connectorArtifactIdentity?: string;
+};
 
 export interface PackageConnectorServiceAuthority {
   schemaVersion: 1;
@@ -27,6 +33,7 @@ export interface PackageConnectorServiceAuthority {
   mode: 'launchd' | 'systemd-user' | 'portable';
   persistent: boolean;
   servicePath?: string;
+  connectorArtifactIdentity?: string;
   installedAt: string;
 }
 
@@ -37,6 +44,7 @@ export interface PackageConnectorServiceResult {
   servicePath?: string;
   pid?: number;
   reused?: boolean;
+  rebound?: boolean;
   releaseId?: string;
   releaseRoot?: string;
 }
@@ -56,8 +64,7 @@ function atomicWrite(path: string, content: string, mode = 0o600): void {
 
 export function packageConnectorServicePaths(controllerHome: string, accountHome = process.env.HOME ?? homedir()): PackageConnectorServicePaths {
   const home = resolve(controllerHome);
-  const suffix = createHash('sha256').update(home).digest('hex').slice(0, 12);
-  const label = `com.moretea.forge.mcp-gateway.${suffix}`;
+  const label = forgeConnectorPersistentServiceLabel(home);
   const serviceRoot = join(home, 'runtime', 'connector-service');
   return {
     label,
@@ -67,6 +74,7 @@ export function packageConnectorServicePaths(controllerHome: string, accountHome
     stdoutPath: join(serviceRoot, 'logs', 'stdout.log'),
     stderrPath: join(serviceRoot, 'logs', 'stderr.log'),
     authorityPath: join(serviceRoot, 'authority.json'),
+    activeEntrypointPath: join(serviceRoot, 'active-forge-mcp-gateway'),
   };
 }
 
@@ -82,13 +90,15 @@ export function readPackageConnectorServiceAuthority(controllerHome: string): Pa
     || typeof parsed.packageRoot !== 'string'
     || !['launchd', 'systemd-user', 'portable'].includes(String(parsed.mode))
     || typeof parsed.persistent !== 'boolean'
+    || (parsed.connectorArtifactIdentity !== undefined && !/^sha256:[a-f0-9]{64}$/i.test(parsed.connectorArtifactIdentity))
     || typeof parsed.installedAt !== 'string'
   ) throw new Error('FORGE_PACKAGE_CONNECTOR_AUTHORITY_INVALID');
   return parsed as PackageConnectorServiceAuthority;
 }
 
-function writePackageConnectorServiceAuthority(input: { release: PackageConnectorReleaseBinding; controllerHome: string; result: PackageConnectorServiceResult }): void {
+function writePackageConnectorServiceAuthority(input: { release: PackageConnectorReleaseBinding; controllerHome: string; result: PackageConnectorServiceResult; installedAt?: string }): void {
   const paths = packageConnectorServicePaths(input.controllerHome);
+  const artifact = attestedCompiledConnector(input.release);
   const authority: PackageConnectorServiceAuthority = {
     schemaVersion: 1,
     endpoint: input.result.endpoint,
@@ -98,7 +108,8 @@ function writePackageConnectorServiceAuthority(input: { release: PackageConnecto
     mode: input.result.mode,
     persistent: input.result.persistent,
     ...(input.result.servicePath ? { servicePath: input.result.servicePath } : {}),
-    installedAt: new Date().toISOString(),
+    ...(artifact ? { connectorArtifactIdentity: artifact.identity } : {}),
+    installedAt: input.installedAt ?? new Date().toISOString(),
   };
   atomicWrite(paths.authorityPath, `${JSON.stringify(authority, null, 2)}\n`);
 }
@@ -173,13 +184,73 @@ export function packageConnectorAuthMode(controllerHome: string): PackageConnect
     : 'oauth';
 }
 
+function attestedCompiledConnector(release: PackageConnectorReleaseBinding): { target: string; identity: string } | undefined {
+  const entrypoint = release.connectorEntrypoint;
+  const identity = release.connectorArtifactIdentity?.trim();
+  if (!entrypoint && !identity) return undefined;
+  if (entrypoint !== 'forge-mcp-gateway' || !identity || !/^sha256:[a-f0-9]{64}$/i.test(identity)) {
+    throw new Error('FORGE_PACKAGE_CONNECTOR_ARTIFACT_ATTESTATION_INVALID');
+  }
+  const target = resolve(release.releaseRoot, entrypoint);
+  const root = resolve(release.releaseRoot);
+  if (dirname(target) !== root || !existsSync(target)) throw new Error('FORGE_PACKAGE_CONNECTOR_ARTIFACT_MISSING');
+  const status = lstatSync(target);
+  if (!status.isFile() || status.isSymbolicLink()) throw new Error('FORGE_PACKAGE_CONNECTOR_ARTIFACT_INVALID');
+  const actual = `sha256:${createHash('sha256').update(readFileSync(target)).digest('hex')}`;
+  if (actual !== identity.toLowerCase()) throw new Error('FORGE_PACKAGE_CONNECTOR_ARTIFACT_IDENTITY_MISMATCH');
+  return { target, identity: actual };
+}
+
+function stableConnectorEntrypointMatches(path: string, target: string): boolean {
+  try {
+    const current = lstatSync(path);
+    const desired = statSync(target);
+    if (!current.isFile() || current.isSymbolicLink() || !desired.isFile()) return false;
+    if (current.size !== desired.size || (current.mode & 0o777) !== (desired.mode & 0o777)) return false;
+    return readFileSync(path).equals(readFileSync(target));
+  } catch {
+    return false;
+  }
+}
+
+export function syncPackageConnectorActiveEntrypoint(input: { release: PackageConnectorReleaseBinding; controllerHome: string; accountHome?: string }): { path: string; target?: string; artifactIdentity?: string; changed: boolean } {
+  const paths = packageConnectorServicePaths(input.controllerHome, input.accountHome);
+  const artifact = attestedCompiledConnector(input.release);
+  if (!artifact) return { path: paths.activeEntrypointPath, changed: false };
+  if (stableConnectorEntrypointMatches(paths.activeEntrypointPath, artifact.target)) {
+    return { path: paths.activeEntrypointPath, target: artifact.target, artifactIdentity: artifact.identity, changed: false };
+  }
+  mkdirSync(dirname(paths.activeEntrypointPath), { recursive: true, mode: 0o700 });
+  const temporary = `${paths.activeEntrypointPath}.${process.pid}.tmp`;
+  rmSync(temporary, { force: true, recursive: true });
+  try {
+    copyFileSync(artifact.target, temporary);
+    chmodSync(temporary, statSync(artifact.target).mode & 0o777);
+    renameSync(temporary, paths.activeEntrypointPath);
+  } finally {
+    rmSync(temporary, { force: true, recursive: true });
+  }
+  if (!stableConnectorEntrypointMatches(paths.activeEntrypointPath, artifact.target)) {
+    throw new Error('FORGE_PACKAGE_CONNECTOR_STABLE_ENTRYPOINT_MIRROR_FAILED');
+  }
+  return { path: paths.activeEntrypointPath, target: artifact.target, artifactIdentity: artifact.identity, changed: true };
+}
+
 export function packageConnectorLaunchSpec(input: { release: PackageConnectorReleaseBinding; controllerHome: string; endpoint: string; executable?: string }): { executable: string; args: string[]; environment: Record<string, string>; port: number; authMode: PackageConnectorAuthMode } {
   const parsed = new URL(input.endpoint);
   const port = Number(parsed.port);
   if (parsed.protocol !== 'http:' || parsed.hostname !== '127.0.0.1' || parsed.pathname !== '/mcp' || !Number.isInteger(port) || port < 1 || port > 65_535) {
     throw new Error('FORGE_PACKAGE_CONNECTOR_ENDPOINT_INVALID');
   }
-  const executable = resolve(input.executable ?? process.env.FORGE_CONNECTOR_EXECUTABLE ?? process.execPath);
+  const attestedConnector = attestedCompiledConnector(input.release);
+  const legacyCompiledConnector = join(resolve(input.release.releaseRoot), 'forge-mcp-gateway');
+  const hasLegacyCompiledConnector = !attestedConnector && existsSync(legacyCompiledConnector);
+  const hasCompiledConnector = Boolean(attestedConnector) || hasLegacyCompiledConnector;
+  const executable = resolve(attestedConnector
+    ? packageConnectorServicePaths(input.controllerHome).activeEntrypointPath
+    : hasLegacyCompiledConnector
+      ? legacyCompiledConnector
+      : input.executable ?? process.env.FORGE_CONNECTOR_EXECUTABLE ?? process.execPath);
   if (/^forge-recovery-(?:gateway|watchdog)$/i.test(basename(executable))) {
     throw new Error('FORGE_PACKAGE_CONNECTOR_EXECUTABLE_INVALID');
   }
@@ -201,7 +272,7 @@ export function packageConnectorLaunchSpec(input: { release: PackageConnectorRel
   ];
   return {
     executable,
-    args: isBun ? [cliEntry, ...cliArgs] : ['--loader', nodeLoader, cliEntry, ...cliArgs],
+    args: hasCompiledConnector ? cliArgs : isBun ? [cliEntry, ...cliArgs] : ['--loader', nodeLoader, cliEntry, ...cliArgs],
     environment: {
       FORGE_CONTROLLER_HOME: resolve(input.controllerHome),
       FORGE_CONTROLLER_LIFECYCLE_OWNER: '1',
@@ -253,9 +324,14 @@ export function packageConnectorServiceMatchesRelease(input: {
   executable?: string;
 }): boolean {
   try {
-    if (
-      input.authority.endpoint !== input.endpoint
-      || input.authority.releaseId !== input.release.releaseId
+    if (input.authority.endpoint !== input.endpoint) return false;
+    const artifact = attestedCompiledConnector(input.release);
+    if (artifact) {
+      const paths = packageConnectorServicePaths(input.controllerHome, input.env?.HOME);
+      if (input.authority.connectorArtifactIdentity !== artifact.identity) return false;
+      if (!stableConnectorEntrypointMatches(paths.activeEntrypointPath, artifact.target)) return false;
+    } else if (
+      input.authority.releaseId !== input.release.releaseId
       || resolve(input.authority.releaseRoot) !== resolve(input.release.releaseRoot)
       || resolve(input.authority.packageRoot) !== resolve(input.release.packageRoot)
     ) return false;
@@ -295,11 +371,7 @@ function installSystemd(paths: PackageConnectorServicePaths, launch: ReturnType<
 function startPortable(paths: PackageConnectorServicePaths, launch: ReturnType<typeof packageConnectorLaunchSpec>, env: NodeJS.ProcessEnv, host: PlatformServiceManagerHost): number {
   // A connector is not the Canonical Runtime writer. Never let a transient
   // installer/worker write claim escape into this long-lived process.
-  const childEnv = { ...env };
-  for (const key of [
-    'FORGE_RUNTIME_INSTANCE_ID', 'FORGE_RUNTIME_OWNER_PID', 'FORGE_RELEASE_AUTHORITY_REVISION',
-    'FORGE_RELEASE_FENCING_TOKEN', 'FORGE_RELEASE_ID', 'FORGE_ARTIFACT_IDENTITY', 'FORGE_WORKER_PROTOCOL_VERSION',
-  ]) delete childEnv[key];
+  const childEnv = runtimeAuthorityFreeEnvironment(env);
   return host.startDetached({
     executable: launch.executable,
     args: launch.args,
@@ -313,6 +385,7 @@ function startPortable(paths: PackageConnectorServicePaths, launch: ReturnType<t
 export async function installPackageConnectorService(input: { release: PackageConnectorReleaseBinding; controllerHome: string; endpoint: string; executable?: string; platform?: NodeJS.Platform; env?: NodeJS.ProcessEnv; forcePortable?: boolean; probeEndpoint?: (endpoint: string) => Promise<boolean> }): Promise<PackageConnectorServiceResult> {
   const paths = packageConnectorServicePaths(input.controllerHome, input.env?.HOME);
   mkdirSync(join(paths.serviceRoot, 'logs'), { recursive: true, mode: 0o700 });
+  syncPackageConnectorActiveEntrypoint({ release: input.release, controllerHome: input.controllerHome, accountHome: input.env?.HOME });
   const launch = packageConnectorLaunchSpec({
     release: input.release,
     controllerHome: input.controllerHome,
@@ -393,15 +466,28 @@ export async function ensurePackageConnectorService(input: {
       })
       && await (input.probeEndpoint ?? defaultConnectorEndpointProbe)(input.endpoint)
     ) {
-      return {
+      const rebound = authority.releaseId !== input.release.releaseId
+        || resolve(authority.releaseRoot) !== resolve(input.release.releaseRoot)
+        || resolve(authority.packageRoot) !== resolve(input.release.packageRoot);
+      const reused: PackageConnectorServiceResult = {
         endpoint: authority.endpoint,
         mode: authority.mode,
         persistent: true,
         ...(authority.servicePath ? { servicePath: authority.servicePath } : {}),
         reused: true,
-        releaseId: authority.releaseId,
-        releaseRoot: authority.releaseRoot,
+        ...(rebound ? { rebound: true } : {}),
+        releaseId: input.release.releaseId,
+        releaseRoot: input.release.releaseRoot,
       };
+      if (rebound) {
+        writePackageConnectorServiceAuthority({
+          release: input.release,
+          controllerHome: input.controllerHome,
+          result: reused,
+          installedAt: authority.installedAt,
+        });
+      }
+      return reused;
     }
   }
   return installPackageConnectorService(input);