@amaster.ai/employee-runtime-connector 0.1.1-beta.123 → 0.1.1-beta.124

package/README.md

@@ -37,7 +37,7 @@ Runtime code belongs in the container image. Persist only connector state, the r
 
 The Server requires `final_model_context_attestation_v1` for governed Pi runs because that path disables ambient context discovery and injects a run-owned compiled instruction bundle. This is a Pi delivery contract, not a connector-wide requirement: an explicitly selected self-hosted Codex runtime continues through its own Runtime Actions V2 and native-session contracts and cannot borrow the Pi attestation claim. Adding the same final-context guarantee to another executor requires executor-specific proof for scoped project-instruction semantics, the normalized final active tool schemas, the selected model's context/output limits, automatically visible skill metadata, resumed-session history, and the enforced output reserve.
 
-For admitted Pi runs, the daemon compiles source-repository `AGENTS.md` and `AGENTS.override.md` topology into one root `AGENTS.md` with explicit relative scopes, same-scope override semantics, and a higher-authority MirrorX platform block. Governed Pi disables ambient extension, skill, and context-file discovery and injects that exact compiled file through a run-owned final-system-prompt extension. A last-ordered `before_provider_request` hook then validates every provider call, including later calls after tool results: exactly one system message contains the compiled instructions, visible role-skill metadata and the normalized active tool set match their prior attestations, the provider model/output ceiling match the run contract, and the complete serialized payload plus output reserve fits the context window. Each call appends metadata-only hashes and sizes to a bounded chained receipt; a missing, broken, or oversized chain fails the run.
+For admitted Pi runs, the daemon compiles source-repository `AGENTS.md` and `AGENTS.override.md` topology into one root `AGENTS.md` with explicit relative scopes, same-scope override semantics, and a higher-authority MirrorX platform block. Governed Pi disables ambient extension, skill, and context-file discovery and injects that exact compiled file through a run-owned final-system-prompt extension. When the operator-owned Pi settings declare `@amaster.ai/pi-telemetry`, the daemon resolves only that package-owned entry, requires the runtime npm manifest to pin its exact installed version, verifies its name, path, and tree digest, passes it as an explicit extension, and preserves the authoritative runtime run id for trace correlation; every other ambient package extension remains disabled. A last-ordered `before_provider_request` hook then validates every provider call, including later calls after tool results: exactly one system message contains the compiled instructions, visible role-skill metadata and the normalized active tool set match their prior attestations, the provider model/output ceiling match the run contract, and the complete serialized payload plus output reserve fits the context window. Each call appends metadata-only hashes and sizes to a bounded chained receipt; a missing, broken, or oversized chain fails the run.
 
 Pi 0.80.10's internal compaction summarizer calls the provider outside `before_provider_request`. The Enabled profile therefore records and cancels every `session_before_compact` attempt and fails immediately if `session_compact` is nevertheless observed. No model-generated compaction summary is accepted until that provider path has equivalent final-context attestation. The Server also enumerates Pi and Codex as the only supported governed executors at configuration and heartbeat dispatch boundaries; missing or unknown executor kinds fail closed.
 

package/dist/amaster-runtime-daemon.mjs

@@ -18870,6 +18870,8 @@ var MANAGED_PI_DIRECT_TYPED_MCP_TOOL_MODE = "direct_typed";
 var MANAGED_PI_MCP_ARGS_NORMALIZATION = "json_string_control_characters_v1";
 var MANAGED_PI_MCP_ARGS_NORMALIZER_FILENAME = "amaster-mcp-args-normalizer.js";
 var MANAGED_PI_CONFIG_MODE_SHARED = "shared_agent_dir_workspace_mcp_file";
+var MANAGED_PI_TELEMETRY_PACKAGE = "@amaster.ai/pi-telemetry";
+var MANAGED_PI_TELEMETRY_PACKAGE_SOURCE = "npm:@amaster.ai/pi-telemetry";
 function applyManagedPiToolAllowlist(args, profile) {
   const toolAllowlist = Array.isArray(profile?.toolAllowlist) ? profile.toolAllowlist.filter((name) => typeof name === "string" && name) : [];
   if (toolAllowlist.length === 0) return [...args];
@@ -19031,6 +19033,10 @@ function createManagedPiMcpProfileApi(options = {}) {
     "PAPERCLIP_AGENT_ID",
     "PAPERCLIP_COMPANY_ID",
     "AMASTER_EMPLOYEE_COMPANY_ID",
+    // Runtime telemetry is a governed audit channel. The daemon assigns this
+    // correlation id from the authoritative run and the managed profile must
+    // preserve it when rebuilding the child environment.
+    "PI_TELEMETRY_TASK_RUN_ID",
     // The agent dir is operator-owned configuration: governed runs inherit the
     // daemon's single value verbatim. commandEnv cannot inject it
     // (FORBIDDEN_COMMAND_ENV).
@@ -19441,6 +19447,98 @@ function createManagedPiMcpProfileApi(options = {}) {
     }
     return version;
   }
+  function managedPiTelemetryExtension(sharedRuntime) {
+    const settings = record8(sharedRuntime.settings);
+    const packages = Array.isArray(settings.packages) ? settings.packages : [];
+    const configuredSources = packages.filter((source) => typeof source === "string" && (source === MANAGED_PI_TELEMETRY_PACKAGE_SOURCE || source.startsWith(`${MANAGED_PI_TELEMETRY_PACKAGE_SOURCE}@`)));
+    if (configuredSources.length === 0) return null;
+    if (configuredSources.length !== 1) {
+      throw new Error("pi_managed_mcp_telemetry_package_source_invalid");
+    }
+    const configuredSource = configuredSources[0];
+    const settingsVersion = configuredSource.startsWith(`${MANAGED_PI_TELEMETRY_PACKAGE_SOURCE}@`) ? configuredSource.slice(MANAGED_PI_TELEMETRY_PACKAGE_SOURCE.length + 1) : null;
+    if (settingsVersion !== null && !/^\d+\.\d+\.\d+(?:[-+].+)?$/.test(settingsVersion)) {
+      throw new Error("pi_managed_mcp_telemetry_package_source_unpinned");
+    }
+    const runtimeManifestPath = join5(sharedRuntime.home, "npm", "package.json");
+    let runtimeManifest;
+    try {
+      const runtimeManifestStat = lstatSync3(runtimeManifestPath);
+      if (!runtimeManifestStat.isFile() || runtimeManifestStat.isSymbolicLink()) {
+        throw new Error("unsafe runtime package manifest");
+      }
+      runtimeManifest = record8(JSON.parse(readFileSync5(runtimeManifestPath, "utf8")));
+    } catch {
+      throw new Error("pi_managed_mcp_telemetry_runtime_manifest_unavailable");
+    }
+    const pinnedVersion = typeof record8(runtimeManifest.dependencies)[MANAGED_PI_TELEMETRY_PACKAGE] === "string" ? record8(runtimeManifest.dependencies)[MANAGED_PI_TELEMETRY_PACKAGE].trim() : "";
+    if (!/^\d+\.\d+\.\d+(?:[-+].+)?$/.test(pinnedVersion)) {
+      throw new Error("pi_managed_mcp_telemetry_runtime_manifest_unpinned");
+    }
+    if (settingsVersion !== null && settingsVersion !== pinnedVersion) {
+      throw new Error("pi_managed_mcp_telemetry_package_source_version_mismatch");
+    }
+    const packageRoot = resolve3(
+      sharedRuntime.home,
+      "npm",
+      "node_modules",
+      "@amaster.ai",
+      "pi-telemetry"
+    );
+    const packageJsonPath = join5(packageRoot, "package.json");
+    let packageJson;
+    try {
+      const packageStat = lstatSync3(packageRoot);
+      if (!packageStat.isDirectory() || packageStat.isSymbolicLink()) throw new Error("unsafe package root");
+      const packageJsonStat = lstatSync3(packageJsonPath);
+      if (!packageJsonStat.isFile() || packageJsonStat.isSymbolicLink()) throw new Error("unsafe package manifest");
+      packageJson = record8(JSON.parse(readFileSync5(packageJsonPath, "utf8")));
+    } catch {
+      throw new Error("pi_managed_mcp_telemetry_package_unavailable");
+    }
+    if (packageJson.name !== MANAGED_PI_TELEMETRY_PACKAGE) {
+      throw new Error("pi_managed_mcp_telemetry_package_invalid");
+    }
+    const version = typeof packageJson.version === "string" ? packageJson.version.trim() : "";
+    if (!/^\d+\.\d+\.\d+(?:[-+].+)?$/.test(version)) {
+      throw new Error("pi_managed_mcp_telemetry_package_version_invalid");
+    }
+    if (version !== pinnedVersion) {
+      throw new Error("pi_managed_mcp_telemetry_package_version_mismatch");
+    }
+    const declaredExtensions = Array.isArray(record8(packageJson.pi).extensions) ? record8(packageJson.pi).extensions : [];
+    if (declaredExtensions.length !== 1 || typeof declaredExtensions[0] !== "string") {
+      throw new Error("pi_managed_mcp_telemetry_extension_invalid");
+    }
+    const extensionPath = resolve3(packageRoot, declaredExtensions[0]);
+    if (!within2(extensionPath, packageRoot)) {
+      throw new Error("pi_managed_mcp_telemetry_extension_unsafe");
+    }
+    try {
+      const extensionStat = lstatSync3(extensionPath);
+      if (!extensionStat.isFile() || extensionStat.isSymbolicLink()) throw new Error("unsafe extension entry");
+      const realPackageRoot = realpathSync3(packageRoot);
+      const realExtensionPath = realpathSync3(extensionPath);
+      if (!within2(realExtensionPath, realPackageRoot)) throw new Error("extension escaped package root");
+    } catch {
+      throw new Error("pi_managed_mcp_telemetry_extension_unsafe");
+    }
+    let packageTreeSha256;
+    try {
+      packageTreeSha256 = trustedTreeDigest(packageRoot, { ignoredRootEntries: ["node_modules"] });
+    } catch {
+      throw new Error("pi_managed_mcp_telemetry_package_unsafe");
+    }
+    return {
+      packageName: MANAGED_PI_TELEMETRY_PACKAGE,
+      packageVersion: version,
+      packageVersionSource: "runtime_npm_manifest",
+      extensionPath,
+      extensionSha256: sha2563(readFileSync5(extensionPath)),
+      packageTreeSha256,
+      langfuseEnabled: record8(record8(settings["pi-telemetry"]).langfuse).enabled === true
+    };
+  }
   function adapterServerConfigHash(definition, adapterVersion) {
     const identity2 = piMcpAdapterServerConfigIdentity(definition, adapterVersion);
     return sha2563(stablePiJson(identity2));
@@ -19809,7 +19907,7 @@ function createManagedPiMcpProfileApi(options = {}) {
     for (const [name, value] of Object.entries(settingsEnv)) {
       if (isSensitiveAuthKey2(name)) protectedValues.push(value);
     }
-    return { home, settingsEnv, protectedValues };
+    return { home, settings, settingsEnv, protectedValues };
   }
   const SKILL_PROFILE_NAME = /^[a-z0-9-]+$/;
   function readSkillProfile(piHome, skillProfile) {
@@ -20431,6 +20529,10 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
           ...sourceAttestationProfilePath ? { sourceProfilePath: sourceAttestationProfilePath } : {}
         };
       }
+      const telemetryExtension = managedPiTelemetryExtension(sharedRuntime);
+      if (telemetryExtension) {
+        extensionArgs.push("--extension", telemetryExtension.extensionPath);
+      }
       let enabledRoleSkills = null;
       let enabledRoleSkillMetadataBytes = 0;
       let enabledRoleSkillMetadataSha256 = null;
@@ -20448,6 +20550,9 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
       const env = {
         ...sharedRuntime.settingsEnv,
         ...buildIsolatedEnvironment2(input.baseEnv, input.commandEnv),
+        // The profile owns the final child environment. Never rely on a caller
+        // supplied correlation value when governed telemetry is active.
+        ...telemetryExtension ? { PI_TELEMETRY_TASK_RUN_ID: runId } : {},
         HOME: home,
         PI_AGENT_HOME: piAgentHome,
         PI_CODING_AGENT_SESSION_DIR: sessionsRoot,
@@ -20531,7 +20636,18 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
           enabledRoleSkills,
           enabledRoleSkillMetadataBytes,
           enabledRoleSkillMetadataSha256
-        )
+        ),
+        telemetryExtensionStatus: telemetryExtension ? "attested" : "not_configured",
+        ...telemetryExtension ? {
+          telemetryPackageName: telemetryExtension.packageName,
+          telemetryPackageVersion: telemetryExtension.packageVersion,
+          telemetryPackageVersionSource: telemetryExtension.packageVersionSource,
+          telemetryExtensionPath: telemetryExtension.extensionPath,
+          telemetryExtensionSha256: telemetryExtension.extensionSha256,
+          telemetryPackageTreeSha256: telemetryExtension.packageTreeSha256,
+          telemetryLangfuseEnabled: telemetryExtension.langfuseEnabled,
+          telemetryRunCorrelationStatus: "authoritative"
+        } : {}
       };
       return {
         profileRoot,
@@ -28497,7 +28613,7 @@ function createSourceCompletionStopPolicy({
 }
 
 // src/amaster-runtime-daemon.mjs
-var CONNECTOR_VERSION = "0.1.1-beta.123";
+var CONNECTOR_VERSION = "0.1.1-beta.124";
 var CONNECTOR_CONTRACT_VERSION = "2026-06-04.v1";
 var SOURCE_ACQUISITION_CAPABILITY2 = source_acquisition_compatibility_default.profileVersion;
 var daemonRequire = createRequire(import.meta.url);

package/dist/amaster-runtime.mjs

@@ -6,7 +6,7 @@ import { basename, dirname, join, resolve } from "node:path";
 import { homedir, hostname } from "node:os";
 import { fileURLToPath } from "node:url";
 
-const CONNECTOR_VERSION = "0.1.1-beta.123";
+const CONNECTOR_VERSION = "0.1.1-beta.124";
 
 const CAPABILITIES = [
   "remote_registration",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amaster.ai/employee-runtime-connector",
-  "version": "0.1.1-beta.123",
+  "version": "0.1.1-beta.124",
   "description": "MirrorX runtime connector CLI and daemon",
   "license": "MIT",
   "type": "module",